C++（二）----类和对象

一、前言

众所周知，C++与C语言不同的地方就是，C++引入了类和对象，可以在兼容C语言的同时面向对象编程，同时具备了封装、继承、多态三种特点（划重点）。面向对象可以说是C++最重要的部分了，而类和对象就是面向对象的基础，所以这一节我们学习类和对象。

二、类

C++是如何引入类的呢？

事实上，类源于C语言的结构体，并且对其进行了扩展。C语言中，结构体有成员，如各种数据类型、数组等，C++中新增了一种玩法，可以定义成员函数。

struct WXH
{
	//成员变量
	int a;
	char b[20];
	
	void test()//成员函数
	{
		cout<<"北京航空航天大学"<< endl;
	}
	void push(char ch,int i)//成员函数
	{
		b[i] = ch;
	}
};

int main()
{
	WXH wxh;
	tmp.test();//打印"北京航空航天大学"
	tmp.push('a',1);//数组b下标为1的位置会被插入一个字符'a'
}

在C++中，C的结构体就是类，并且C++中更喜欢用class替代struct
所以类的定义和结构体相似：

class className
{
	// 类体：由成员函数和成员变量组成
};//注意这里有个分号

类成员变量的定义和结构体相同，类的成员函数有两种定义方式：
1.声明和定义都在类中：

class people
{
	char* name;
	char* sex;
	int height;
	int age;
	void peoinfo()//打印此人的消息
	{
		cout<<name<<" "<<sex<<" "<<height<<" "<<age;
	}
};

这种情况下，编译器可能会把这个函数当成内联函数处理（建议，具体看函数代码长度）
2.声明定义分离（指声明放在.h头文件，而定义放在.cpp源文件）：

//.h文件
class people
{
	char* name;
	char* sex;
	int height;
	int age;
	void peoinfo()//打印此人的消息
};

//.cpp文件，注意这里在函数名前一定要加上类名 people 和域解析运算符 :: 否则系统也不知道你要定义之前声明的类的成员函数还是新的函数
void people::peoinfo()//打印此人的消息
	{
		cout<<name<<" "<<sex<<" "<<height<<" "<<age;
	}

C++的封装

前面我们知道了封装是C++的一个特性，那么C++是如何实现封装的呢？
事实上，C++实现封装的方式是：用类将对象的属性与方法结合在一块，让对象更加完善，通过访问权限选择性的将其接口提供给外部的用户使用。接下来先介绍类的三个访问限定符：

1.public修饰的成员在类外，可以直接被访问，而protected和private修饰的成员在类外不能直接被访问，具体如何访问我们后面再讲。

2.访问权限作用域：从该访问限定符出现的位置开始，直到下一个访问限定符出现时为止。如果后面没有访问限定符了，作用域就一直到类结束

3.class的默认访问权限为private，struct为public(因为要兼容C，C的结构体成员可以直接在外面访问)

class wxh
{
public:
	int num;
	void test1()
	{
		cout<<"haha";
	}

	void test2()
	{
		cout<<"hehe";
	}

private:
	int a;
	char b[20];
	double c;
}

int main()
{
	wxh tmp;
	tmp.test1();//正常运行
	tmp.num=0;//public限定的成员可以访问
	tmp.a = 10;//
	tmp.c = 20;//private成员不能在类外访问
	return 0;
}

无论成员函数私有还是公共，也无论成员变量私有还是公共，成员函数都可以访问到成员变量（因为在类内部）
通过访问限定符的限制，C++相对C语言更好实现了封装，讲到这，估计同学们还不知道什么叫封装吧，我们通过下面这道题来理解：
【面试题】面向对象的三大特性：封装、继承、多态。在类和对象阶段，我们只研究类的封装特性，那什么是封装呢？
封装：将数据和操作数据的方法进行有机结合，隐藏对象的属性和实现细节，仅对外公开接口来和对象进行交互。
再打个比喻：
封装本质上是一种管理：我们如何管理兵马俑呢？比如如果什么都不管，兵马俑就被随意破坏了。那么我们首先建了一座房子把兵马俑（类的某些成员和函数）给封装起来。但是我们目的全封装起来，不让别人看。所以我们开放了售票通道（类的公开接口，多为公共函数），可以买票突破封装在合理的监管机制下进去参观。类也是一样，我们使用类数据和方法都封装到一下。不想给别人看到的，我们使用protected/private把成员封装起来。开放一些共有的成员函数对成员合理的访问。所以封装本质是一种管理。

此外，可能有些同学以及注意到了，上面的某个例子中，我们在类后面跟了域解析运算符 ::，这是因为类本身就指定了一个域：类域。

class Person
{
public:
 void PrintPersonInfo();
private:
 char _name[20];
 char _gender[3];
 int _age;
};
// 这里需要指定PrintPersonInfo是属于Person这个类域
void Person::PrintPersonInfo()
{
 cout<<_name<<" "_gender<<" "<<_age<<endl;
}

类的实例化

那类如何使用呢？
都说类和对象，肯定不止有类，还有对象。
实际上：

类只是一个模型一样的东西，限定了类有哪些成员，定义出一个类并没有分配实际的内存空间来存储它
一个类可以实例化出多个对象，实例化出的对象占用实际的物理空间，存储类成员变量
做个比方。类实例化出对象就像现实中使用建筑设计图建造出房子，类就像是设计图，只设计出需要什么东西，但是并没有实体的建筑存在，同样类也只是一个设计，实例化出的对象才能实际存储数据，占用物理空间。结构体也是这样的，在定义结构体的时候占据内存空间，定义一个结构体的变量才会占用空间。从这个角度看，类和数据类型类似，只不过它定义出来的叫对象。

用类类型创建对象的过程，称为类的实例化

类的大小及存储方式

类中既可以有成员变量，又可以有成员函数，那么一个类的对象中包含了什么？如何计算一个类的大
小？我们先看看编译器怎么说：

我们发现，诶？A和B居然一模一样，看来A这个函数没有占据空间啊？
再看，B的这个空间和结构体一样啊，确实是，按照结构体对齐规则算出来就是B的大小
最后，C这个空类居然还也有大小？
这里给出关于类对象大小的结论：

类中的成员函数不算在类的大小中
类的大小遵守结构体内存对齐规则（什么？结构体对齐规则忘了?快回去复习）
空类(没有成员变量)的大小是1字节

那类的对象存储模式是怎么样的呢？为什么函数就不算空间呢？
事实上，类对象的存储模式是：对象空间+公共代码段。其中，类成员变量存储在实例化对象中，而类成员函数存储在公共的代码段

其实也好理解，不同的对象，它们存的成员变量的值可能不同，所以应该把它们分别存在各个对象中，但是对成员函数的调用是一样的，所以为了节省空间，将成员函数从对象中剥离到公共代码段，不管实例化多少对象，只要调用成员函数就去找公共代码段即可。

可以看到，一个类的大小，实际就是该类中”成员变量”之和。（当然也要进行内存对齐）

而空类比较特殊，编译器给了空类一个字节来唯一标识这个类。

this指针

C++中，类有一个特殊的成员： this
这里我们先定义一个日期类：

class Date
{ 
public :
	
 void Display ()//显示当前日期
 {
 cout <<_year<< "-" <<_month << "-"<< _day <<endl;
 }
 
 void SetDate(int year , int month , int day)//设置当前日期
 {
 _year = year;
 _month = month;
 _day = day;
 }
private :
 int _year ; // 年
 int _month ; // 月
 int _day ; // 日
};
int main()
{
 Date d1, d2;
 d1.SetDate(2024,5,1);
 d2.SetDate(2024,7,1);
 d1.Display();
 d2.Display();
 return 0;
}

这个Date类中有SetDate与Display两个成员函数，函数体中没有关于不同对象的区分，那当s1调用SetDate函数时，该函数是如何知道应该设置s1对象，而不是设置s2对象呢？
（别忘了，成员函数可是放在公共代码段的）

C++中通过引入this指针解决该问题，即：C++编译器给每个“非静态的成员函数“增加了一个隐藏的指针参数，让该指针指向当前对象(函数运行时调用该函数的对象)，在函数体中所有成员变量的操作，都是通过该指针去访问。只不过所有的操作对用户是透明的，即用户不需要来传递，编译器自动完成。

this指针特性：

this指针的类型：类* const
只能在“成员函数”的内部使用
this指针本质上其实是一个成员函数的形参，是对象调用成员函数时，将对象地址作为实参传递给this形参。类似于这样：func(&A);(但是我们不能像左边这样显式调用)所以对象中不需要存储this指针。
this指针是成员函数第一个隐含的指针形参，一般情况由编译器通过ecx寄存器自动传递，不需要用户传递
第四点什么意思呢？就是：

这个箭头转换的过程是编译器自动搞的，不需要你去处理，你也看不到。

在多个参数时，this指针是第一个参数：

前面我们说了，每个对象的成员变量是各自存储的，在用公共代码进行赋值的时候也用到了this指针：

this指针可以很好地区分不同对象。

三、类的特殊成员函数

构造函数

在我们使用各种数据结构时，（我）时常发生诸如忘记初始化/忘记销毁等，造成一些不好的影响和bug（如野指针、内存泄漏等）所以我们的祖师爷在发明类时，直接帮我们设计了6个默认成员函数，即使是一个空类class Class{};

我们首先介绍构造函数：
构造函数，顾名思义，就是用于初始化的函数，既然是专门用于初始化的函数，那么方便至上，最好能在创建对象的时候就把信息设置进去用于初始化。构造函数就可以做到。
构造函数是一个特殊的成员函数，名字与类名相同,创建类的对象时由编译器自动调用，保证每个数据成员都有一个合适的初始值，并且在对象的生命周期内只调用一次。
也就是说，构造函数不用我们调用就可以对对象进行初始化。其实，构造函数是特殊的成员函数，需要注意的是，构造函数的虽然名称叫构造，但是需要注意的是构造函数的主要任务并不是开空间创建对象，而是初始化对象。下面这些是构造函数的特征：

函数名与类名相同。
无返回值。
对象实例化时编译器自动调用对应的构造函数。
构造函数可以重载。

class Date
{
public :
 // 1.无参构造函数
 Date ()//无返回值
 {}
 // 2.带参构造函数
 Date (int year, int month , int day )
 {
 _year = year ;
 _month = month ;
 _day = day ;
 }
private :
 int _year ;
 int _month ;
 int _day ;
};
void TestDate()
{
 Date d1; // 调用无参构造函数
 Date d2 (2025, 1, 1); // 调用带参的构造函数
 
 // 注意：如果通过无参构造函数创建对象时，对象后面不用跟括号，否则就成了函数声明,比如下面的代码是声明了一个d3函数，该函数无参，返回一个日期类型的对象
 Date d3(); 
}

如果类中没有显式定义构造函数，则C++编译器会自动生成一个无参的默认构造函数，一旦用户显式定义编译器将不再生成：

class Date
{
private :
 int _year ;//int _year = 1 ;给缺省值的写法，注意这个不是赋值是缺省值
 int _month ;
 int _day ;
};
void TestDate()
{
 Date d1; //即便没有定义，编译器会自己生成一个默认构造函数，但是值是随机的，
 		  //对此C++11新增了一个补丁，这些值可以给一个默认的缺省值，如果没有显式传参则初始化为缺省值
}

无参的构造函数和全缺省的构造函数都称为默认构造函数，并且默认构造函数只能有一个（只能同时存在一个，因为都不需要传参，如果有两个则会让系统不知道用哪个）
注意：无参构造函数、全缺省构造函数、我们没写编译器默认生成的构造函数，都可以认为是默认成员函数

// 默认构造函数
class Date
{ 
public:
 Date()
 {
 _year = 1900 ;
 _month = 1 ;
 _day = 1;
 }
 
 Date (int year = 1900, int month = 1, int day = 1)
 {
 _year = year;
 _month = month;
 _day = day;
 }
private :
 int _year ;
 int _month ;
 int _day ;
};
// 以下测试函数能通过编译吗？
//答案是不能，因为两个构造函数都是默认构造函数
void Test()
{
 Date d;
}

关于编译器生成的默认成员函数，很多同学会有疑惑：在我们不实现构造函数的情况下，编译器会生成默认的构造函数。但是看起来默认构造函数又没什么用？d对象调用了编译器生成的默认构造函数，但是d对象year/month/_day，依旧是随机值。也就说在这里编译器生成的默认构造函数并没有什么卵用？？
事实上，C++把类型分成内置类型(基本类型)和自定义类型。内置类型就是语法已经定义好的类型：如int/char…，自定义类型就是我们使用class/struct/union自己定义的类型，看看下面的程序，就会发现编译器生成默认的构造函数会对自定类型成员_t调用的它的默认成员函数

class Time
{
public:
 Time()
 {
 cout << "Time()" << endl;
 _hour = 0;
 _minute = 0;
 _second = 0;
 }
private:
 int _hour;
 int _minute;
 int _second;
};
class Date
{
private:
 // 基本类型(内置类型)
 int _year;
 int _month;
 int _day;
 // 自定义类型
 Time _t;
};
int main()
{
 Date d;
 return 0;
}

这里，对于_year _month _day，初始化仍然为随机值，但对于自定义的Time类型的_t，默认构造函数也会调用它的构造函数

在创建对象后，我们可以使用构造函数对其成员变量一个合适的初始值，如：

class Date
{
public:
 Date(int year, int month, int day)
 {
 _year = year;
 _month = month;
 _day = day;
 }
 
private:
 int _year;
 int _month;
 int _day;
};

虽然上述构造函数调用之后，对象中已经有了一个初始值，但是不能将其称作为类对象成员的初始化，构造函数体中的语句只能将其称作为赋初值，而不能称作初始化。因为初始化只能初始化一次，而构造函数体内可以多次赋值。所以就有了——初始化列表：

初始化列表：以一个冒号开始，接着是一个以逗号分隔的数据成员列表，每个"成员变量"后面跟一个放在括号中的初始值或表达式。

class Date
{
public:
 Date(int year, int month, int day)//下面三行就是初始化列表
 : _year(year)
 , _month(month)
 , _day(day)
 {}
 
private:
 int _year;
 int _month;
 int _day;
};

初始化列表的特点：

每个成员变量在初始化列表中只能出现一次(初始化只能初始化一次)
类中包含以下成员，必须放在初始化列表位置进行初始化：
引用成员变量、const成员变量（初始化后不能再改变值）、自定义类型成员(没有默认构造函数)，如下

class A
{
public:
 A(int a)
 :_a(a)
 {}
private:
 int _a;
};
class B
{
public:
 B(int a, int ref)
 :_aobj(a)
 ,_ref(ref)
 ,_n(10)
 {}
private:
 A _aobj; // 没有默认构造函数
 int& _ref; // 引用
 const int _n; // const 
};

尽量使用初始化列表初始化，因为不管你是否使用初始化列表，对于自定义类型成员变量，一定会先使用初始化列表初始化

class Time
{
public:
 Time(int hour = 0)
 :_hour(hour)
 {
 cout << "Time()" << endl;
 }
private:
 int _hour;
};
class Date
{
public:
 Date(int day)
 {}
private:
 int _day;
 Time _t;
};
int main()
{
 Date d(1);
}

成员变量在类中声明次序就是其在初始化列表中的初始化顺序，与其在初始化列表中的先后次序无关，仔细观察以下代码：

class A
{
public:
 A(int a)
 :_a1(a)
 ,_a2(_a1)
 {}
 
 void Print() {
 cout<<_a1<<" "<<_a2<<endl;
 }
private:
 int _a2;
 int _a1;
}
int main() {
 A aa(1);
 aa.Print();
}

结果是1 随机值
explicit关键字：
构造函数不仅可以构造与初始化对象，对于单个参数的构造函数，还具有类型转换的作用。
仔细观察下面这个代码：

class Date
{
public:
 Date(int year)
 :_year(year)
 {}
 
 explicit Date(int year)
 :_year(year)
 {}
 
private:
 int _year;
 int _month:
 int _day;
}；
void TestDate()
{
 Date d1(2024);
 
 // 用一个整形变量给日期类型对象赋值
 // 实际编译器背后会用2019构造一个临时对象，最后用无名对象给d1对象进行赋值，但是这个可读性不好
 d1 = 2025;//C++11还支持多参数的隐式类型转化，需要用括号和逗号
}

这时我们可以用explicit修饰构造函数，将会禁止单参构造函数的隐式转换。

事实上，根据编译器的不同，上述d1=2025也可能直接构造，因为编译器会把构造无名对象+赋值整个优化为直接构造。

Date d2 = 2;
Date& d3 =2;
const date& d4 =2；

众所周知，临时对象具有常性，且在转化后销毁。这里2转化成的临时对象可以赋值给d2 d4 ，不能给d3（权限扩大），同时在复制给d4的这个临时对象因为被引用，其生命周期延长了。
除了临时对象，C++还有匿名对象：

A a(7);//有名对象
A(7);//匿名对象

匿名对象的生命周期只有一行，会自动调用析构，同学们可以在析构函数中设置打印来测试匿名对象的生命周期，匿名对象主要用于非隐式类型转换的简化代码

.
.
.

下面是关于变量命名的一些思考

// 关于变量命名的一些小问题
class Date
{
public:
 Date(int year)
 {
 // 这里的year到底是成员变量，还是函数形参？
 year = year;
 }
private:
 int year;
};
// 所以我们一般都建议这样
class Date
{
public:
 Date(int year)
 {
 _year = year;
 }
 private:
 int _year;
};
// 或者这样。
class Date
{
public:
 Date(int year)
 {
 m_year = year;
 }
private:
 int m_year;
};
// 其他方式也可以的，主要看公个人习惯/公司要求。一般都是加个前缀或者后缀标识区分就行。

析构函数

构造函数是用于创建一个对象，那该怎么销毁一个对象呢？
这就用到析构函数了。析构函数：与构造函数功能相反，析构函数不是完成对象的销毁，局部对象销毁工作是由编译器完成的。而对象在销毁时会自动调用析构函数，完成类的一些资源清理工作。
析构函数也是类的一个特殊成员函数，有下面几个特征：

析构函数名是在类名前加上字符 ~。
析构函数无参数无返回值。
一个类有且只有一个析构函数。若未显式定义，系统会自动生成默认的析构函数。
对象生命周期结束时，C++编译系统系统自动调用析构函数。

typedef int DataType;
class SeqList
{ 
public :
 SeqList (int capacity = 10)
 {
 _pData = (DataType*)malloc(capacity * sizeof(DataType));
 assert(_pData);
 
 _size = 0;
 _capacity = capacity;
 }
 
 ~SeqList()
 {
 if (_pData)
 {
 free(_pData ); // 释放堆上的空间
 _pData = NULL; // 将指针置为空
 _capacity = 0;
 _size = 0;
 }
 }
 
private :
 int* _pData ;
 size_t _size;
 size_t _capacity;
};

编译器生成的默认析构函数，对会自定类型成员调用它的析构函数：

class String
{
public:
 String(const char* str = "jack")
 {
 _str = (char*)malloc(strlen(str) + 1);
 strcpy(_str, str);
 }
 ~String()
 {
 cout << "~String()" << endl;
 free(_str);
 }
private:
 char* _str;
};
class Person
{
private:
 String _name;
 int _age;
};
int main()
{
 Person p;
 return 0;
}

拷贝构造函数

在创建对象时，可否创建一个与一个对象一某一样的新对象呢？
用拷贝构造函数即可。拷贝构造函数：只有单个形参，该形参是对本类类型对象的引用(一般常用const修饰)，在用已存在的类类型对象创建新对象时由编译器自动调用
拷贝构造函数有以下特征：

拷贝构造函数是构造函数的一个重载形式。
拷贝构造函数的参数只有一个且必须使用引用传参，使用传值方式会引发无穷递归调用：

class Date
{
public:
 Date(int year = 1900, int month = 1, int day = 1)
 {
 _year = year;
 _month = month;
 _day = day;
 }
 Date(const Date& d)
 {
 _year = d._year;
 _month = d._month;
 _day = d._day;
 }
private:
 int _year;
 int _month;
 int _day;
};
int main()
{
 Date d1;
 Date d2(d1);
 return 0;
}

上面这段代码是正确的，但是如果把拷贝构造函数改成Date(const Date d)就会有问题，因为我们都知道，函数在传参的时候，形参是实参的拷贝，也就是说，在Date d2(d1);生成d这个形参的时候，先把d1拷贝给了d，但是类是如何进行拷贝的呢？答案是使用拷贝构造函数！但是我们定义的拷贝构造函数是传值拷贝，在新的拷贝构造函数中，形参又是实参的拷贝，如此一来，直接套娃，程序也会陷入死循环。
可如果使用传引用传参，形参是实参的别名，就不会有拷贝实参的过程，自然也就不会有死循环了

3. 若未显式定义，系统生成默认的拷贝构造函数。默认的拷贝构造函数对象按内存存储按字节序完成拷贝，这种拷贝我们叫做浅拷贝，或者值拷贝。

class Date
{
public:
 Date(int year = 1900, int month = 1, int day = 1)
 {
 _year = year;
 _month = month;
 _day = day;
 }
private:
 int _year;
 int _month;
 int _day;
};
int main()
{
 Date d1;
 // 这里d2调用的默认拷贝构造完成拷贝，d2和d1的值也是一样的。
 Date d2(d1);
 return 0;
}

这个时候可能就会有同学要问了，既然编译器已经能做到了那我们还写它吗？
先不急，先看看下面这个：

// 这里会发现下面的程序会崩溃掉？这里就需要我们以后讲的深拷贝去解决。
class String
{
public:
 String(const char* str = "jack")
 {
 _str = (char*)malloc(strlen(str) + 1);
 strcpy(_str, str);
 }
 ~String()
 {
 cout << "~String()" << endl;
 free(_str);
 }
private:
 char* _str;
};
int main()
{
 String s1("hello");
 String s2(s1);
}

咦？程序居然崩了？
其实，这是由于类涉及到动态内存分配与回收，而且使用了浅拷贝导致的。对于编译器自动生成的拷贝构造函数，会简单地把参数的值按字节拷贝给新类，在上面的程序中，s1里的_str动态申请了堆空间的一块区域，s2则会把它的值拷贝过来，这就导致两个类的_str指向同一块区域，这本身不会崩掉，但是在程序结束销毁lei时，调用了两次析构函数（这里肯定要写free的，否则内存泄露了），这样就把同一块区域给free了两次，于是程序就崩掉了。

注：以下两个写法都是拷贝构造

Date d1(2023,7,30);
Date d2(d1);//标准拷贝构造
Date d3 = d1;//不是赋值运算符重载（接下来讲）而是拷贝构造

运算符重载

类的第四个特殊成员函数是赋值运算符重载，这里我们直接讲解更一般的运算符重载。
首先我们在日期类中定义一个对象：

Date d1(2023,7,31);

如果我们想用这个对象进行计算，比如想知道100天后的日期，对日期类这个自定义类型肯定是不能直接+的。我们可能需要一个函数（类似数据结构的接口一样），但是在C++中，通过赋值运算符重载，我们依然能实现如下的功能：

Date d2 = d1+100; //普通的加号肯定不能实现此功能

实际上，C++为了增强代码的可读性，引入了运算符重载，运算符重载是具有特殊函数名的函数，也具有其返回值类型，函数名字以及参数列表，其返回值类型和参数列表与普通函数类似。其实就是说，在这里这个 + 就是一个函数，只不过C++为了好读直接让它变成了这种形式。

函数名字为：关键字operator后面接需要重载的运算符符号。
函数原型：返回值类型 operator操作符(参数列表)
注意：
1.不能通过连接其他符号来创建新的操作符：比如operator@
2.重载操作符必须有一个类类型或者枚举类型的操作数
3.用于内置类型的操作符，其含义不能改变，例如：内置的整型+，不能改变其含义，作为类成员的重载函数时，其形参看起来比操作数数目少1，成员函数的操作符有一个默认的形参this，限定为第一个形参
4..* 、:: 、sizeof 、?: 、. 注意以上5个运算符不能重载。（这个经常在笔试选择题中出现）

具体如何实现？请看下面

// 全局的operator==
class Date
{ 
public:
 Date(int year = 1900, int month = 1, int day = 1)
 {
 _year = year;
 _month = month;
 _day = day;
 } 
//private:
 int _year;
 int _month;
 int _day;
};
// 这里会发现运算符重载成全局的就需要成员变量是共有的，那么问题来了，封装性如何保证？
// 这里其实可以用我们后面学习的友元解决，或者干脆重载成成员函数。
bool operator==(const Date& d1, const Date& d2)
{
 return d1._year == d2._year;
 && d1._month == d2._month
 && d1._day == d2._day;
}
void Test ()
{
 Date d1(2018, 9, 26);
 Date d2(2018, 9, 27);
 cout<<(d1 == d2)<<endl;//这里d1 == d2相当于operator==(d1,d2)
}

或者：

//运算符重载--成员函数版
class Date
{ 
public:
 Date(int year = 1900, int month = 1, int day = 1)
 {
 _year = year;
 _month = month;
 _day = day;
 }
 
 // bool operator==(Date* this, const Date& d2)
 // 这里需要注意的是，左操作数是this指向的调用函数的对象
 bool operator==(const Date& d2)
 {
 return _year == d2._year;
 && _month == d2._month
 && _day == d2._day;
 }
private:
 int _year;
 int _month;
 int _day;
};
void Test ()
{
 Date d1(2018, 9, 26);
 Date d2(2018, 9, 27);
 cout<<(d1 == d2)<<endl;//这里d1 == d2相当于d1.operator==(d2)
}

讲过一般的运算符重载，我们再来讲讲赋值运算符重载：

class Date
{ 
public :
 Date(int year = 1900, int month = 1, int day = 1)
 {
 _year = year;
 _month = month;
 _day = day;
 }
 
 Date (const Date& d)
 {
 _year = d._year;
 _month = d._month;
 _day = d._day;
 }
 
 Date& operator=(const Date& d)
 {
 if(this != &d)
 {
 	_year = d._year;
	_month = d._month;
 	_day = d._day;
 }
 return *this;
 }
private:
 int _year ;
 int _month ;
 int _day ;
};

赋值运算符主要有五点：

参数类型
返回值
检测是否自己给自己赋值
返回*this
一个类如果没有显式定义赋值运算符重载，编译器也会生成一个，完成对象按字节序的值拷贝。

class Date
{
public:
 Date(int year = 1900, int month = 1, int day = 1)
 {
 _year = year;
 _month = month;
 _day = day;
 }
private:
 int _year;
 int _month;
 int _day;
};
int main()
{
 Date d1;
 Date d2(2018，10， 1);
 
 // 这里d1调用的编译器生成operator=完成拷贝，d2和d1的值也是一样的。
 d1 = d2；
 return 0;
}

当然，与拷贝构造函数类似，即使有了编译器的值拷贝，我们仍然需要自己写，以防止重复free而出错的问题

取地址及const取地址操作符重载

class Date
{ 
public :
 Date* operator&()
 {
 return this ;
 }
 
 const Date* operator&()const
 {
 return this ;
 }
private :
 int _year ; // 年
 int _month ; // 月
 int _day ; // 日
};

这两个一般不需要重载，编译器给出的就可以，只有某些特殊的情况需要重载，比如想让别人获取指定的内容

const成员

const修饰类的成员函数
我们将const修饰的类成员函数称之为const成员函数，const修饰类成员函数，实际修饰的是类成员函数隐含的this指针，表明在该成员函数中不能对this指针指向的对象进行修改。

	void Print() const// cosnt修饰的打印函数，const要放在函数名后面，这样可以防止在函数中不小心修改了对象
	{
		cout << _year << "年" << _month << "月" << _day << "日" << endl;
	}

思考下面几个问题（经典面试题）：
1.const对象可以调用非const成员函数吗？
2.非const对象可以调用const成员函数吗？
3.const成员函数内可以调用其他的非const成员函数吗？
4.非cosnt成员函数内可以调用其他的cosnt成员函数吗？

答案是：不可以、可以、不可以、可以
解释如下：
1.非const成员函数，即成员函数的this指针没有被const所修饰，我们传入一个被const修饰的对象，用没有被const修饰的this指针进行接收，属于权限的放大，函数调用失败。
2.const成员函数，即成员函数的this指针被const所修饰，我们传入一个没有被const修饰的对象，用被const修饰的this指针进行接收，属于权限的缩小，函数调用成功。
3.在一个被const所修饰的成员函数中调用其他没有被const所修饰的成员函数，也就是将一个被const修饰的this指针的值赋值给一个没有被const修饰的this指针，属于权限的放大，函数调用失败。
4.在一个没有被const所修饰的成员函数中调用其他被const所修饰的成员函数，也就是将一个没有被const修饰的this指针的值赋值给一个被const修饰的this指针，属于权限的缩小，函数调用成功。

那么，下面这两个函数可以同时存在吗：

void print() const
void print()

答案是可以存在，因为参数类型不同（this指针带不带const不一样）
如果两个函数同时存在，会有限选择最匹配的，如果不匹配，那么非const对象可以用const的函数，但是反过来不行（本质还是权限可以缩小但不能放大）

四、类的一些拓展知识

static成员

声明为static的类成员称为类的静态成员，用static修饰的成员变量，称之为静态成员变量；用static修饰的成员函数，称之为静态成员函数。静态的成员变量一定要在类外进行初始化。

面试题：实现一个类，计算中程序中创建出了多少个类对象。
一个简单是思路是，构造一个变量，在构造函数中++，这样每创建一个类就加一。显然这个变量不能是类的成员变量，否则每次都会重新初始化，这个变量应该是独立在类之外的，此时就用到静态变量：

class A
{
public:
 A() {++_scount;}
 A(const A& t) {++_scount;}
 static int GetACount() { return _scount;}
private:
 static int _scount;//静态对象
 };
int A::_count = 0;//类外定义
void TestA()
{
 cout<<A::GetACount()<<endl;
 A a1, a2;
 A a3(a1);
 cout<<A::GetACount()<<endl;
}

特点：

静态成员为所有类对象所共享，不属于某个具体的实例（自然也不计算在某个对象所占空间大小）
静态成员变量必须在类外定义、初始化（可以突破private限制），定义时不添加static关键字，类中只是声明
类静态成员即可用类名::静态成员或者对象.静态成员来访问
静态成员函数没有隐藏的this指针，不能访问任何非静态成员

含有私有静态成员变量的类，一般含有一个静态成员函数，用于访问静态成员变量

静态成员和类的普通成员一样，也有public、protected、private3种访问级别，也可以具有返回值

【问题】
静态成员函数可以调用非静态成员函数吗？非静态成员函数可以调用类的静态成员函数吗？
答案是不能，因为没有this指针代入；能，因为都在类中

友元

友元分为：友元函数和友元类
友元提供了一种突破封装的方式，有时提供了便利。但是友元会增加耦合度，破坏了封装，所以友元不宜多用。
友元函数：
问题：现在我们尝试去重载operator<<，然后发现我们没办法将operator<<重载成成员函数。因为cout的输出流对象和隐含的this指针在抢占第一个参数的位置。this指针默认是第一个参数也就是左操作数了。但是实际使用中cout需要是第一个形参对象，才能正常使用。所以我们要将operator<<重载成全局函数。但是这样的话，又会导致类外没办法访问成员，那么这里就需要友元来解决。operator>>同理。

class Date
{
public:
 Date(int year, int month, int day)
 : _year(year)
 , _month(month)
 , _day(day)
 {}
 
 ostream& operator<<(ostream& _cout)
 {
 _cout<<d._year<<"-"<<d._month<<"-"<<d._day;
 return _cout;
 }
 
prvate:
 int _year;
 int _month;
 int _day
};
int main()
{
Date d(2017, 12, 24);
 d<<cout;//不是我们平时使用的cout<<
 return 0;
}

友元函数可以直接访问类的私有成员，它是定义在类外部的普通函数，不属于任何类，但需要在类的内部声明，声明时需要加friend关键字。

class Date
{
friend ostream& operator<<(ostream& _cout, const Date& d);
friend istream& operator>>(istream& _cin, Date& d);
public:
 Date(int year, int month, int day)
 : _year(year)
 , _month(month)
 , _day(day)
 {}
 
private:
 int _year;
 int _month;
 int _day；
};

ostream& operator<<(ostream& _cout, const Date& d)
{
 _cout<<d._year<<"-"<<d._month<<"-"<<d._day;
 
 return _cout;
}

istream& operator>>(istream& _cin, Date& d)
{
 _cin>>d._year;
 _cin>>d._month;
 _cin>>d._day;
 
 return _cin;
}
int main()
{
 Date d;
 cin>>d;
 cout<<d<<endl;//这样就和我们的cin>> cout<<用法一样了
 return 0;
}

友元函数可访问类的私有和保护成员，但不是类的成员函数。友元函数不能用const修饰。友元函数可以在类定义的任何地方声明，不受类访问限定符限制。一个函数可以是多个类的友元函数。友元函数的调用与普通函数的调用和原理相同。

友元类：
友元类的所有成员函数都可以是另一个类的友元函数，都可以访问另一个类中的非公有成员。
友元关系是单向的，不具有交换性。
比如在Time类中声明Date类为其友元类，那么可以在Date类中直接访问Time，类的私有成员变量，但想在Time类中访问Date类中私有的成员变量则不行。

相当于单向朋友，你在类中说明我是你的friend，那我就可以进你的类里使用私有和保护，但是你不能进我的类中使用私有和保护

友元关系不能传递：如果B是A的友元，C是B的友元，则不能说明C时A的友元。

class Date; // 前置声明一个类
class Time
{
 friend class Date; // 声明日期类为时间类的友元类，则在日期类中就直接访问Time类中的私有成
员变量
public:
 Time(int hour, int minute, int second)
 : _hour(hour)
 , _minute(minute)
 , _second(second)
 {}
 
private:
 int _hour;
 int _minute;
 int _second;
};

class Date
{
public:
 Date(int year = 1900, int month = 1, int day = 1)
 : _year(year)
 , _month(month)
 , _day(day)
 {}
 
 void SetTimeOfDate(int hour, int minute, int second)
 {
 // 直接访问时间类私有的成员变量
 _t._hour = hour;
 _t._minute = minute;
 _t.second = second;
 }
 
private:
 int _year;
 int _month;
 int _day;
 Time _t;
};

内部类

概念：如果一个类定义在另一个类的内部，这个内部类就叫做内部类。注意此时这个内部类是一个独立的类，它不属于外部类，更不能通过外部类的对象去调用内部类。外部类对内部类没有任何优越的访问权限。
注意：内部类就是外部类的友元类。注意友元类的定义，内部类可以通过外部类的对象参数来访问外部类中的所有成员。但是外部类不是内部类的友元。
特性：

内部类可以定义在外部类的public、protected、private都是可以的。
注意内部类可以直接访问外部类中的static、枚举成员，不需要外部类的对象/类名。
sizeof(外部类)=外部类，和内部类没有任何关系

class A
{
private:
 static int k;
 int h;
 
public:

 class B
 {
 public:
 void foo(const A& a)
 {
 cout << k << endl;//OK
 cout << a.h << endl;//OK
 }
 };//内部类B


};//外部类A
int A::k = 1;
int main()
{
 A::B b;
 b.foo(A());
 
 return 0;
}

五、C++再认识

再次理解封装
C++是基于面向对象的程序，面向对象有三大特性即：封装、继承、多态。
C++通过类，将一个对象的属性与行为结合在一起，使其更符合人们对于一件事物的认知，将属于该对象的所有东西打包在一起；通过访问限定符选择性的将其部分功能开放出来与其他对象进行交互，而对于对象内部的一些实现细节，外部用户不需要知道，知道了有些情况下也没用，反而增加了使用或者维护的难度，让整个事情复杂化。

下面举个例子来让大家更好的理解封装性带来的好处：乘火车出行
我们来看下火车站：
售票系统：负责售票----用户凭票进入，对号入座
工作人员：售票、咨询、安检、保全、卫生等
火车：带用户到目的地

火车站中所有工作人员配合起来，才能让大家坐车有条不紊的进行，不需要知道火车的构造，票务系统是如何操作的，只要能正常方便的应用即可。

想想下，如果是没有任何管理的开放性站台呢？火车站没有围墙，站内火车管理调度也是随意，乘车也没有规矩，甚至乘车人可以随意访问各种内部数据和系统，这势必导致意想不到的后果。

再次理解面向对象
可以看出面向对象其实是在模拟抽象映射现实世界。