C++基础回顾（二）

看视频课程：C++面向对象编程

第8节面向对象基础

第9节定义类和对象

struct  与 class 在C++中都可以定义类，struct默认为public，而class默认为private。

成员函数申明与定义的两种方式：
1.类内定义，类内实现，print()函数
2.类内定义，类外实现，getAge()函数
这里，第一种类内定义的默认为内联函数，类外定义的要手动添加inline！

第10节类和对象的使用

/*Student stu;
stu.print();
cout<<stu.getAge()<<endl;*/

/*Student stu;
Student *p = &stu;
p->print();
cout<<p->getAge()<<endl;*/

Student stu;
Student &s = stu;
s.print();
cout<<s.getAge()<<endl;

//使用宏指令，防止重复定义
#ifndef TIME_H
#define TIME_H
//...
#endif

头文件Time.h

#ifndef TIME_H
#define TIME_H
class CTime
{
public:
void setHour(int hour);
void setMinute(int minute);
void setSecond(int second);

int getHour();
int getMinute();
int getSecond();
private:
int m_nHour;
int m_nMinute;
int m_nSecond;
};
#endif

cpp文件Time.cpp

#include "Time.h"

void CTime::setHour(int hour)
{
m_nHour = hour;
}
vo
4000
id CTime::setMinute(int minute)
{
m_nMinute = minute;
}
void CTime::setSecond(int second)
{
m_nSecond = second;
}

int CTime::getHour()
{
return m_nHour;
}
int CTime::getMinute()
{
return m_nMinute;
}
int CTime::getSecond()
{
return m_nSecond;
}

运行文件main.cpp

#include<iostream>
#include"Time.h"
using namespace std;

int main()
{
CTime time;
time.setHour(10);
time.setMinute(50);
time.setSecond(20);

cout<<time.getHour()<<":"<<time.getMinute()<<":"<<time.getSecond()<<endl;
return 0;
}

Visual Studio 2012常用快捷键总结

1）注释：组合键“Ctrl+K+C”；

2）取消注释：组合键“Ctrl+K+U”。

第11节构造函数和析构函数

CTime::CTime()    //默认构造函数
{
m_nHour = 0;
m_nMinute = 0;
m_nSecond = 0;
}

CTime::~CTime()   //析构函数
{
std::cout<<"~CTime"<<std::endl;
std::cout << "Object is being deleted" << std::endl;
}

CTime::CTime(int value)      //带一个参数的构造函数
{
m_nHour = value;
m_nMinute = value;
m_nSecond = value;
}

CTime::CTime(int hour, int minute, int second)
{
m_nHour = hour;
m_nMinute = minute;
m_nSecond = second;
}

没有构造函数时会提供默认不带参的构造函数，有构造函数时就不会提供默认构造函数了！
注意一下，默认参数构造函数，不能给所有参数提供默认值，这样可能会导致歧义！

第12节this指针和复制构造函数

复制构造函数也是构造函数的一种，有了复制构造函数就不会有默认的构造函数了



this指针：

void CTime::setMinute(int minute)
{
m_nMinute = minute;    //this指针隐藏
//this->m_nMinute = minute;       //->方式
//(*this).m_nMinute = minute;     //.方式，this是指针，*this是对象
}

复制构造函数：

CTime::CTime(CTime& time)
{
m_nHour = time.m_nHour;
m_nMinute = time.m_nMinute;
m_nSecond = time.m_nSecond;
cout<<"Copy constructor!"<<endl;
}

//1.以其对象作为参数创建新对象时
CTime time5(time);

//2.类对象（传值）作为函数参数时
void func1(CTime time)
{
 cout<<time.getHour();
}

//3.类对象作为参数返回值时
/*CTime func1(CTime time)
{
cout<<time.getHour();
return time;
}*/
//应该为引用的方式返回，较少复制产生花销，注意不能返回局部变量的引用：
CTime& func1(CTime& time)
{
cout<<time.getHour();
return time;
}

第14节const对象和const成员

const数据成员，不能在构造函数里赋值，只能通过初始化列表初始化，且每个构造函数要用初始化列表对其进行初始化。
初始化列表形式如下：a(1),b(2)

CTime::CTime()
:m_nNum(10)
{
m_nHour = 0;
m_nMinute = 0;
m_nSecond = 0;
//这样编译不通过
//m_nNum = 0;
}
CTime::CTime(int value)
:m_nNum(20)
{
m_nHour = value;
m_nMinute = value;
m_nSecond = value;
}
CTime::CTime(int hour, int minute, int second)
:m_nNum(1)
{
m_nHour = hour;
m_nMinute = minute;
m_nSecond = second;
}
CTime::CTime(CTime& time)
:m_nNum(time.m_nNum)
{
m_nHour = time.m_nHour;
m_nMinute = time.m_nMinute;
m_nSecond = time.m_nSecond;
cout<<"Copy constructor!"<<endl;
}

//const数据成员
const int m_nNum;

//const成员函数
int getNum()const;

int CTime::getNum()const{return m_nNum;}

//const对象time和time2
const CTime time(10, 50, 20);
CTime const time2(12, 20, 12);
/*const对象不能调用非const类型的成员函数
time.getHour();
time2.setHour();*/
cout<<time.getNum()<<endl;

第15节友元

1.将非成员函数声明为友元：
在CTime类的头文件Time.h中添加，友元函数，要访问CTime类的私有数据成员

//将非成员函数声明为友元函数
friend void func();

void func()
{
CTime time(1,1,1);
cout<<time.m_nHour<<endl;
time.m_nHour = 3;
cout<<time.m_nHour<<endl;
}

2.友元类、其他类的成员函数声明为友元函数

注意一下友元类的声明位置与其他类声明为友元函数时的声明位置，实例如下：
CDate类要访问CTime类的私有成员，即在CTime类的头文件Time.h中添加，友元类或友元函数

//友元类
//friend CDate;
//友元函数即可
friend void CDate::display(const CTime& time);

Date.h文件

#ifndef DATE_H
#define DATE_H

//类前置声明
class CTime;
class CDate
{
public:
//构造函数
CDate(int year, int month, int day);

//友元类，不能索取，只能给与，所以应该在CTime类中声明友元类CDate
//friend CTime;
void display(const CTime& time);
private:
int m_nYear;
int m_nMonth;
int m_nDay;
};
#endif

Date.cpp

#include"Date.h"
#include"Time.h"
#include<iostream>

CDate::CDate(int year, int month, int day)
:m_nYear(year), m_nMonth(month), m_nDay(day)
{
}
void CDate::display(const CTime& time)
{
std::cout<<m_nYear<<"-"<<m_nMonth<<"-"<<m_nDay<<" "<<time.m_nHour<<":"<<time.m_nMinute<<":"<<time.m_nSecond<<std::endl;
}

main.cpp

const CTime time(10, 50, 20);
CDate date(2018,1,22);
date.display(time);

第16节运算符重载基础

1.一般的函数（加法运算，两个参数）

CTime operator+(CTime& time1, CTime& time2)
{
int nHour = 0, nMinute = 0;
int nSecond = time1.m_nSecond + time2.m_nSecond;
if(nSecond > 60)
{
nMinute ++;
nSecond -= 60;
}
nMinute += (time1.m_nMinute + time2.m_nMinute);
if(nMinute > 60)
{
nHour ++;
nMinute -= 60;
}
nHour += (time1.m_nHour + time2.m_nHour);
if(nHour > 24)
{
nHour -= 24;
}
//构造临时CTime对象
return CTime(nHour, nMinute, nSecond);
}

2.类的成员函数（加法运算，一个参数）

CTime CTime::operator+(CTime& time)
{
int nHour = 0, nMinute = 0;
int nSecond = this->m_nSecond + time.m_nSecond;
if(nSecond > 60)
{
nMinute ++;
nSecond -= 60;
}
nMinute += (this->m_nMinute + time.m_nMinute);
if(nMinute > 60)
{
nHour ++;
nMinute -= 60;
}
nHour += (this->m_nHour + time.m_nHour);
if(nHour > 24)
{
nHour -= 24;
}
//构造临时CTime对象
return CTime(nHour, nMinute, nSecond);
}

第17节运算符重载规则

CTime& CTime::operator=(CTime& time)
{
//判断是否为同一个对象,是一个则返回该对象(*this)
if(this == &time)
{
return *this;
}
m_nHour = time.m_nHour;
m_nMinute = time.m_nMinute;
m_nSecond = time.m_nSecond;

return *this;
}

//调用类的赋值运算函数
time = time3;
cout<<time.getHour()<<":"<<time.getMinute()<<":"<<time.getSecond()<<endl;

//调用复制构造函数
CTime time4 = time3;
CTime time5(time3);

需要将以上两者进行区分，容易混淆！！

第18节重载二元和一元运算符

==与>运算符重载

bool CTime::operator==(CTime& time)
{
if(m_nHour == time.m_nHour && m_nMinute == time.m_nMinute && m_nSecond == time.m_nSecond)
{
return true;
}
return false;
}

bool CTime::operator>(CTime& time)
{
if(m_nHour > time.m_nHour)
{
return true;
}
else if(m_nHour < time.m_nHour)
{
return false;
}
else
{
if(m_nMinute > time.m_nMinute)
{
return true;
}
else if(m_nMinute < time.m_nMinute)
{
return false;
}
else
{
if(m_nSecond > time.m_nSecond)
{
return true;
}
else
{
return false;
}
}
}
return false;
}

bool bRet = time == time2;
bool bRet2 = time > time2;

前置++与后置++运算符重载，前置无参数，后置参数（int）

CTime CTime::operator++()
{
//可以写个函数实现++，更方便的是使用加法的重载函数
//定义time对象(0,0,1)加到当前对象(*this)
CTime time(0, 0, 1);
*this = *this + time;
return *this;
}

CTime CTime::operator++(int)
{
//要返回++前的对象，赋值给time
CTime time = *this;
//可以写个函数实现++，更方便的是使用加法的重载函数
//定义time对象(0,0,1)加到当前对象(*this)
CTime time2(0, 0, 1);
*this = *this + time2;
return time;
}

++time2;
cout<<time2.getHour()<<":"<<time2.getMinute()<<":"<<time2.getSecond()<<endl;
time = time2++;
cout<<time.getHour()<<":"<<time.getMinute()<<":"<<time.getSecond()<<endl;
cout<<time2.getHour()<<":"<<time2.getMinute()<<":"<<time2.getSecond()<<endl;

第19节流插入、提取运算符和类型转换

//流提取>>运算符重载，作为友元函数，不能作为成员函数
istream& operator>>(istream& input, CTime& time)
{
cin>>time.m_nHour>>time.m_nMinute>>time.m_nSecond;
return input;
}
//流插入<<运算符重载，作为友元函数，不能作为成员函数
ostream& operator<<(ostream& output, CTime& time)
{
cout<<time.getHour()<<":"<<time.getMinute()<<":"<<time.getSecond()<<endl;
return output;
}

CTime time2(12);
cin>>time1;
cout<<time1<<endl<<time2<<endl;

1.使用构造函数进行类型转换

CTime time2(12);
time2 + CTime(3);
CTime time3(20);
CTime time4 = 20;
CTime time5 = CTime(20);

有了转换构造函数，以上都不会编译报错，然而：

//具有一个参数的构造函数可以用来做类型转换————称为转换构造函数
//有人说这样方便，也有不同意的人
//通过加关键字explicit,可以防止类型转换
explicit CTime(int value);

2.类型转换函数进行类型转换（不常见）

//类型转换函数,CTime对象转换为int类型
CTime::operator int()
{
return m_nHour * 60 * 60 + m_nMinute * 60 + m_nSecond;
}

CTime time(10,50,20)
int nSecond = time;