C++类对象 （中）

目录

一、类的6个默认成员函数

二、构造函数

三、析构函数

四,拷贝函数

五、赋值运算符重载 &&运算符重载

六、日期类的实现

七、const成员函数

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

一、类的6个默认成员函数

class Date {};

      如果一个类中什么成员都没有，简称为空类。空类中什么都没有吗？并不是的，任何一个类在我们不写的情况下，都会自动生成下面 6 个默认成员函数。

二、构造函数

 概念

 场景 

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

	cout << _year << " "<<_month<<" "<<_day<< endl;
	}
private:
	int _year;
	int _month;
	int _day;
	
};
int main(){
	Date d1;
	d1.SetDate(2020, 3, 17);
	d1.Display;

	Date d2;
	d2.SetDate(2020, 3, 18);
	d2.Display;
	return 0;
}

问 ：对于Date类，可以通过SetDate公有的方法给对象设置内容，但是如果每次创建对象都调用该方法设置信息，未免有点麻烦，那能否在对象创建时，就将信息设置进去呢？ 

class Date
{
public :
//1.无参构造函数
    Date()  
{

}
 //2.带参构造函数
	Date(int year, int month, int day){
		_year = year;
		_month = month;
		_day = day;
	}
	void Display(){

	cout << _year << " "<<_month<<" "<<_day<< endl;
	}
private:
	int _year;
	int _month;
	int _day;
	
};
int main(){
	Date d1; //调用无参构造函数
	Date d2(2022,3,17);//调用带参构造函数

 // 注意：如果通过无参构造函数创建对象时，对象后面不用跟括号，否则就成了函数声明
 // 以下代码的函数：声明了d3函数，该函数无参，返回一个日期类型的对象
 Date d3(); 
	
	return 0;
}

说明:

构造函数是一个特殊的成员函数，名字与类名相同，创建类类型对象时由编译器自动调用，保证每个数据成员都有 一个合适的初始值，并且在对象的生命周期内只调用一次。

特性:

构造函数是特殊的成员函数，需要注意的是，构造函数虽然名称叫构造，但是需要注意的是构造函数的主要任务并不是开空间创建对象，而是初始化对象。

其特征如下：

 1. 函数名与类名相同。

 2.无返回值。

 3.对象实例化时编译器自动调用对应的构造函数。

 4.构造函数可以重载。

接下来我们就来理解几个概念:

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

class Date
{
public:
/*如果用户显示定义构造函数，编译器将不再生成默认构造函数。
  Date(int year,int month,int day){

    _year =year;
    _month= month;
    _day  = day;
} */
//如果没有显示定义构造函数，对象也能创建成功，此时调用的是编译器创建的构造函数。
private:
 int _year;
 int _month;
 int _day;
};


int main(){
 Date d;

return 0;
}

说明：
　
不是说我们不写构造函数，编译器会自动生成一个无参的默认构造函数吗？

这也是早期 C++ 设计留下的一个缺陷，有些编译器会把这初始化为 0，1，1

C++ 把我们的变量分成内置类型 (int、char、指针 …) 和自定义类型 (struct/class)

我们不写构造函数，编译器默认生成构造函数，但是编译器做了一个偏心的处理

1、内置类型不会初始化
2、自定义类型它会调用它的无参构造函数初始化

其实这块内容算是 C++ 在早期设计时的语法缺陷，这种偏心的处理导致语法反而复杂了，后面也发现了这个问题，但是为时已晚不能修改，因为 C++ 要向前兼容。好多书上也没有讲清楚，这也是很多人说 C++ 难学的地方。

2.关于编译器生成的默认构造函数，很多童鞋会有疑惑：在我们不实现构造函数的情况下，编译器会生成默认构造函数，但看起来默认构造函数又没什么用 。

这里说看起来没什么用主要体现在 d 调用了编译器生成的默认构造函数，但是 _year、_month、_day 依然是随机值。

C++ 把类型分成内置类型 (基本类型) 和自定义类型，这里只是说它不会处理内置类型，而自定义类型它会去调用它的无参构造函数来初始化。

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;
}

  

说明：

此时实例化Date类型的d ,因为Date类内没有写构造函数，所以编译器就会自动生成一个构造函数，然后再初始化d,对于d的内置类型变量 _year ，_month，_day，编译器会给一个随机值，对于d里面的自定义类型_t ，编译器会调用Time类的构造函数来初始化_t。因此函数默认生成的构造函数在这里就体现了他的作用。

3.到了 C++11 时 C++ 针对这里的情况做了补充 ？

C++11 时，语法委员会针对这里打了一个补丁，也就是在变量声明中加上缺省值。

这个补丁确实会给很多初学者造成困扰，很多人会认为它是初始化，其实它是缺省值。
 

class A
{
public:
	A()
	{
		cout << "A()" << endl;
	}
private:
	int _a1;
	int _a2;
};
class Date
{
public:
	Date()
	{
		_year = 2022;//只初始化_year，其它默认
	}
	void Print()
	{
		cout << _year << "/" << _month << "/" << _day << endl;	
	}
private:
	//C++11 缺省值
	int _year = 0;
	int _month = 1;
	int _day = 1;
	A _a;
};
int main()
{
	Date d1;
	d1.Print();
	
	return 0;
}

说明:

就同函数的缺省参数一样。如果构造函数里没有初始化，那么对于内置类型它会使用缺省值初始。

4.无参的构造函数和全缺省的构造函数都称为默认构造函数，并且默认构造函数只能有一个。

注意:

无参构造函数、全缺省构造函数、我们没写编译器默认生成的构造函数，都可以认为是默认构造函数 

class Date
{
public:
	Date()       // 无参构造函数 或 全缺省构造函数 都称为 默认构造函数
	{
		_year = 0;
		_month = 1;
		_day = 1;
	}            //全缺省构造函数
	Date(int year = 1, int month = 1, int day = 1)
	{
		_year = year;
		_month = month;
		_day = day;
	}
	void Print()     
	{                 
		cout << _year << "/" << _month << "/" << _day << endl;
	}
private:
	int _year;
	int _month;
	int _day;
};
int main()
{
	Date d1;  //  此时调用构造函数会出现歧义，不知道调用那个
    Date d2(3);// 此时调用构造函数会出现歧义，不知道调用那个
	return 0;
}

说明:

如上两个构造函数 Date 本来是可以构造函数重载的，但是他们不能同时存在 为什么？

因为编译器调用的时候会出现歧义，创建对象时，不知道调用哪一个构造参数。一般情况下我们推荐写一个全缺省的构造函数，因为它不会出现歧义。

这里有一个误区：有的童鞋会认为，我们不写，编译器默认生成的构造函数就叫做默认构造函数，这个是不对的，它还有无参的构造函数和全缺省的构造函数都是默认构造函数。

5.成员变量的命名风格
 

class Date
{
public:
	Date(int year)//不好的命名风格
	{
		year = year;	
	}
	Date(int year,int month)//好的命名风格
	{
		_year = year;
		_month = month;
	}
private:
	int year;
	int _year;
	int _month;
};
int main()
{
	Date d1(1);
	Date d2(1, 2);
	return 0;
}

说明:

当然这样不仅仅是规范的问题，还可能会造成运行时错误。

执行 Date d1 (1) ; 后，year 的值是 1 还是随机值 

站在编译器的角度 this->year = year，所以是 1 ？？？

NO ~~，实际上在 Date 里它会采用就进原则，也可以认为是局部优先。

当 year = year 时，它会先找到形参，然后就变成了自己赋值给自己了。

当 _year = year 时，它先找局部变量，没找到，它会再外面的域搜索，找到了，编译器就会在前面加 this。

或者直接 this->year = year 但不推荐。

三、析构函数

概念
前面通过构造函数的学习，我们知道一个对象时怎么来的，那一个对象又是怎么没呢的 ？？？

析构函数：与构造函数功能相反，析构函数不是完成对象的销毁，局部对象销毁工作是由编译器完成的。而对象在销毁时会自动调用析构函数，完成类的一些资源清理工作。
 

class Date
{
public:
	void Print()
	{
		cout << _year << "/" << _month << "/" << _day << endl;	
	}
	~Date()
	{
		cout << "~Date()" << endl;//证明调用了析构函数
	}
private:
	int _year;
	int _month;
	int _day;
};
int main()
{
	Date d1;
	return 0;
}

说明:

像 Date 这样的类是不需要析构函数的，因为它没有需要释放的资源。

 特性:

析构函数是特殊的成员函数。

其特征如下：

1. 析构函数名是在类名前加上字符 ~。

2. 无参数无返回值 (不支持重载)。因为没有参数

3. 一个类有且只有一个析构函数。若未显式定义，系统会自动生成默认的析构函数。

4. 对象生命周期结束时，C++ 编译系统系统自动调用析构函数。

析构函数有什么意义 

析构函数具体有什么意义要看具体是什么类，哪些类的析构函数是有意义的呢 ？

 对于类里有申请空间操作的，必须要自己写析构函数，要不然会出现内存泄露.

class Stack
{
public:
	Stack(int capacity = 4)
	{
		_a = (int*)malloc(sizeof(int)*capacity);
		if(_a == nullptr)
		{
			cout << "malloc fail" << endl;
			exit(-1);
		}
		_top = 0;
		_capacity = capacity;
	}
	~Stack()
	{
		free(_a);
		_a = nullptr;
	}
private:
	int* _a;
	int _top;
	int _capacity;
};
int main()
{
	Stack st;
	return 0;
}

说明:

在之前我们写栈时都需要写一个 Destroy 在程序结束前销毁动态开辟的内存，很多童鞋可能在使用完动态开辟的内存没有 Destroy 导致后面的一些内存泄漏的操作。而析构函数的出现就是为了解决这种场景的，对象实例化后，同构造函数一样，它不需要我们主动调用，它是在对象生命周期结束后自动调用，注意析构函数没有参数所以不能重载。
一个类有且只有一个析构函数。若未显式定义，系统会自动生成默认的析构函数 

class Stack
{
public:
	Stack(int capacity = 4)
	{
		_a = (int*)malloc(sizeof(int)*capacity);
		if(_a == nullptr)
		{
			cout << "malloc fail" << endl;
			exit(-1);
		}
		_top = 0;
		_capacity = capacity;
	}
private:
	int* _a;
	int _top;
	int _capacity;
};
int main()
{
	Stack st;
	return 0;
}

说明:

与构造函数类似，如果我们不写，编译器默认生成的构造函数也会做偏心的处理

1、内置类型成员不处理
2、自定义类型成员会去调用它的析构函数

那对于什么样的类可以不写析构呢或者它的价值是什么 ？

对于没有申请空间的类，我们析构函数可以不写

class Time{
public:
	Time(){
		cout << "Time()" << endl;
		_hour = 0;
		_minute = 0;
		_second = 0;
	}
     ~Time(){   //写不写都可以
  cout << "说明调用析构函数"<<endl;  
}
private:
	int _hour;
	int _minute;
	int _second;
};

class Date
{
public :
	Date(int year, int month, int day){
		_year = year;
		_month = month;
		_day = day;
	}
	~Date(){    //对于日期而言 ，写不写都可以

	}
private:
	// 内之类型
	int _year;
	int _month;
	int _day;
	// 自定义类型
	Time _t;
};
int main(){

	Date d(2020,3,17);
	return 0;
}

 对于类里面进行了空间申请的，必须调用析构函数进行空间的清理。析构函数必须自己写，如果只是用编译器默认给出的，就会出现内存泄露。

就和构造函数一样。本来要d1.SetDate(1,2,3).现在只需要d1(1,2,3). 析构函数也一样，本来要~Date (d1); 现在只要我写完函数，我就不用再去调用了。他会自己完成析构函数的调用. 

class Stack
{
public:
	Stack(int capacity = 4)
	{
		_a = (int*)malloc(sizeof(int)*capacity);
		if(_a == nullptr)
		{
			cout << "malloc fail" << endl;
			exit(-1);
		}
		_top = 0;
		_capacity = capacity;
	}
	~Stack()
	{
		free(_a);
		_a = nullptr;
	}
private:
	int* _a;
	int _top;
	int _capacity;
};
class MyQueue
{
private:
	 Stack _pushST;
	 Stack _popST;	
};
int main()
{
	MyQueue mq;
	return 0;
}

说明:

这是之前的一个题 —— 两个栈实现队列

现在对于 MyQueue，我们可以写构造函数和析构函数，也可以 Init 和 Destroy，具体如下：

1、初始化 _pushST 和 _popST和销毁_pushST 和 _popST

我们可以看出，不用我们再去调用，编译器会自己调用析构函数。

四,拷贝函数

1.拷贝构造函数典型的调用场景

1：使用已存在的对象创建新对象

2：函数参数类型为类类型对象

3：函数返回值类型为类类型对象

class  Date
{
public :
	Date(int year = 1900, int month=1, int day=1){    //构造函数
		_year = year;
		_month = month;
		_day = day;
		cout << "Date(int ,int ,int ):" << this << endl;
	}
	Date(const Date & d){                             //拷贝构造
		_year = d._year;
		_month = d._month;
		_day = d._day;
		cout << "Date(const Date & d) " << this<<endl;
	}
	~Date(){                                          //析构函数
		cout << "~Date()" << this << endl;
	}
private:
	int _year;
	int _month;
	int _day;

};

// 函数形参为值类型，返回值也为值类型，传递实参为对象，返回类型也为对象类型
Date TestDate(Date param){
	return param;
}



//函数形参为类类型引用 ，返回值类型为类类型引用。
const Date& TestDate(const Date & param){  
	return param;                          
}


void TestFunc(){
	Date d1;
	Date d2(d1);  //使用已存在的对象创建新对象
	TestDate(d1); //两种情况
}

int main(){
	TestFunc();
	return 0;
}

在现实生活中有双胞胎的存在，那么我们的对象也可以有。

class Date
{
public:
 // 全缺省构造函数
	Date(int year = 1, int month = 1, int day = 1)
	{
		_year = year;
		_month = month;
		_day = day;	
	}
	//Date d3(d2);

//  传值传参拷贝构造 这种方法错误，不能实现。
	Date(const Date d)   
	{
	    _year = d._year;
		_month = d._month;
		_day = d._day;
	}
    //Date d2(d1);

//  类类型对象的引用,但是不安全。
	Date(Date & d)   
	{
	    _year = d._year;
		_month = d._month;
		_day = d._day;
        _day++;
	}
    //Date d3(d2);

// 类类型对象的引用，加const更安全。
	Date(const Date& d)
	{
		_year = d._year;
		_month = d._month;
		_day = d._day;
	}
	//Date d3(d2);

//指针类传参，也可以实现。
	Date(const Date* p)
	{
		_year = p->_year;
		_month = p->_month;
		_day = p->_day;
	}	
	void Print()
	{
		cout << _year << "/"<< _month << "/" << _day <<	endl;	
	} 
private:
	int _year;
	int _month;
	int _day;
};
int main()
{
   int a =10 ;
   int b =20;
   int a =b; //这种方式可以实现拷贝
   int a(b);//这种方式也可以实现拷贝
   
    Date d1;  
	Date d2(d1);
	d1.Print();
	d2.Print();
	//拷贝复制一个d2对象
	Date d3(d2);
	d3.Print();
	//指针也可以，但不好
	Date d4(&p2);
	d4.Print();
	return 0;
}

  

error C2652：非法的复制构造函数，第一个参数不应是 “Date”。

这里会引发一个无穷递归的现象，只是语法进行了强制检查，所以它由运行时错误转向了编译时错误。

  说明：

            如果拷贝函数参数是类类型的引用，那么将d1拿过来，拷贝d2.此时d 就是d1 的引用，所以将d类里面的值，传给d2(this指的就是d2),就是d1将自己的参传给d2.可以实现。

          如果拷贝函数参数是值类型，形参是实参的一份拷贝。那么将d1传给值d,此时首先就要创建一个零时对象，用来接受d1。所以创建一个零时对象之后，又要调用拷贝构造，但是此时又要传参，传参又要创建一个零时对象，然后又要拷贝。所以会一直循换下去。

怎么解决 ?

1、这里用引用解决了问题，因为形参是实参的别名，即 d是 d2 的别名

   注意如果引用传参，不是做输出型参数，最好加 const

2、当然也能使用指针解决，但并没有引用好用

 特性
拷贝构造函数也是特殊的成员函数，其特征如下：

拷贝构造函数是构造函数的一个重载形式。

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

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

class Time
{
public:
	Time(){        //Time构造函数
		_hour = 0;
		_minute = 0;
		_second = 0;
		cout <<"Time构造函数"<<endl;
	}

	Time(const Time & t){ // Time拷贝函数
		_hour = t._hour;
		_minute = t._minute;
		_second = t._second;
		cout <<"Time拷贝函数"<<endl;
		
		}
private:
	int _hour;
	int _minute;
	int _second;
};

class Date //没写拷贝函数和构造函数，但是对象还可以创建。编译器自己生成了构造函数和拷贝构造函数
{
private:  
	int _year = 2020;;
	int _month =3;
	int _day =7;
	Time _t;
public:
	void Display(){
		cout << _year<<" "<<_month<<" "<<_day<<" "<< endl;
	}
};

int main(){        
	Date d1;  //创建d1时，编译器会调用编译器生成的Date类的构造函数。然后_year,_month,_day都是他的默认值。然后到Time_t的时候，就会去调用Time类的 构造函数。

	d1.Display(); // 显示 Time构造函数  2020 3 7

	Date d2(d1);  //编译器会自动生成拷贝构造函数 。编译器给Date生成的拷贝构造函数，将d1._year _month _day 拷贝到d2放到了里面。然后调用Time类的构造函数 和拷贝构造函数 完成Date中_t 的拷贝。

	d2.Display();  //  显示 Time构造函数 Time拷贝构造函数 2020 3 7

	return 0;
}

我们不写，编译器默认生成拷贝构造，跟构造和析构不太一样，它不会去区分内置类型和自定义类型，都会处理。

1、内置类型，字节序的浅拷贝 (一个字节一个字节的拷贝)。 

      Date里的int _year int _month int_day 拷贝到 新的 Date对象里面。 

2、自定义类型，会去调用它的拷贝构造完成拷贝。

   Time拷贝函数。将Time 里面的_hour _minute _second 拷贝到 新的Time类对象里面。

那么编译器生成的默认拷贝构造函数已经可以完成字节序的值拷贝了 (内置类型和自定义类型)，是否意味着编译器自己生成的就行呢。我们还需要自己实现吗？当然像日期类这样的类是没必要的。那么下面的类呢？验证一下试试 
 

class Stack
{
public:
	Stack(int capacity = 4)
	{
		_a = (int*)malloc(sizeof(int)*capacity);
		if(_a == nullptr)
		{
			cout << "malloc fail" << endl;
			exit(-1);
		}
		_top = 0;
		_capacity = capacity;
	}
	~Stack()
	{
		free(_a);
		_a = nullptr;
	}
private:
	int* _a;
	int _top;
	int _capacity;
};
int main()
{
	Stack st1;
	Stack st2(st1);
	return 0;
}

说明:

经调试发现虽然已经完成了拷贝，但是程序崩了。

 此时 st1 和 st2 指向同一块空间，那么问题来了，谁先被析构呢 —— 根据栈的特性后进先出，所以这里先被析构的是 st2。st2 被析构后再析构 st1 时程序就崩溃了，因为同一块空间不能释放两次。

编译器默认生成的拷贝构造并不能解决所有问题，像 Stack 这样的类，编译器默认生成拷贝构造完成的就是浅拷贝。解决方案就是自己实现深拷贝，对于深拷贝，因为比较复杂，所以后面要另写一篇文章。

 拷贝 | 拷贝构造 

int p()
{
	int ret = 0;
	return ret;	
}
Date q()
{
	Date ret;
	return ret;
}

说明

我们说了，在传值返回时，它会先拷贝 (实际上是两次拷贝，但有些编译器会优化成一次)。（传值时拷贝一次，返回值时拷贝一次）。

为什么需要拷贝 ？

当函数调用结束，函数栈帧会被销毁，ret 是属于这个栈帧的局部变量，所以拷贝是为了解决局部变量被销毁的问题。使用引用可以解决拷贝消耗，但要注意如果出了作用域返回对象不在了就不能用引用。注意有些编译器在函数结束时不会清理栈帧，所以能返回正确返回值 (如果不是正确返回值，那么说明栈空间被清理了)，但那是非法的。

五、赋值运算符重载 &&运算符重载
 

class Date
{
public:
	Date(int year = 0, int month = 1, int day = 1)
	{
		_year = year;
		_month = month;
		_day = day;	
	}
private:
	int _year;
	int _month;
	int _day;
};
int main()
{
	Date d1(2021, 10, 11);
	Date d2(2020, 11, 11);
	Date d3(2021, 11, 11);
	
	//d1 == d2;//错误
	
	return 0;
}

说明:

d1 == d2 为啥错？

运算符默认都是给内置类型变量用的。

自定义类型的变量想用这些运算符，得自己运算符重载。

运算符重载指的是需要自己写一个函数实现这里运算符的行为。

C++ 为了增强代码的可读性引入了运算符重载，运算符重载是具有特殊函数名的函数，函数里的实现就是行为。它也具有其返回值类型，函数名字以及参数列表，其返回值类型与参数列表与普通的函数类似。

函数名字为：关键字 operator 后面接需要重载的运算符符号。

函数原型：返回值类型 operator 操作符 (参数列表)

注意：对于参数列表的个数有几个是根据操作符来确定的，比如 == 就需要两个参数；参数类型就是你要操作的对象类型；返回值类型就是运算符运算后的返回值。

class Date
{
public:
	Date(int year = 0, int month = 1, int day = 1)
	{
		_year = year;
		_month = month;
		_day = day;	
	}
//private:
public://这里破坏封装使得可以在类外访问成员
	int _year;
	int _month;
	int _day;
};
bool operator==(const Date& x1, const Date& x2)
{
	return x1._year == x2._year
		&& x1._month == x2._month
		&& x1._day == x2._day;
}
int main()
{
	Date d1(2021, 10, 11);
	Date d2(2020, 11, 11);
	Date d3(2021, 11, 11);
	
	operator==(d1, d2);//可以这样调用，但是这样可读性很差，还不如写一个函数
	d1 == d2;//同上，如果没有重载会报错，如果重载了它会转换为 operator==(d1, d2);
	return 0;
}

 说明:

怎么解决上述代码中利用破坏了封装，使得运算符重载的函数可以访问私有成员 ？

将函数重载写在类里，写成一个成员函数。

class Date
{
public:
	Date(int year = 0, int month = 1, int day = 1)
	{
		_year = year;
		_month = month;
		_day = day;	
   cout<<"Date(int,int,int)"<<this<<endl;
	}

    // 写一个比较函数。
    bool IsEqual (const Date& d){    
     return  _year == d._year&&
		     _month == d._month&&
		     _day == d._day;

     }
     //作为全局函数 运算符重载，需要两个参数
	bool operator==(const Date& x1, const Date& x2)//err
	{
		return x1._year == x2._year
			&& x1._month == x2._month
			&& x1._day == x2._day;
	}
	
     // 作为成员函数，只需要传入一个参数，因为他自己还有一个this指针
	//bool operator==(/*Date* this*/, const Date& x)
	bool operator==(const Date& x)
	{
		return _year == x._year
			&& _month == x._month
			&& _day == x._day;
	}
private:
	int _year;
	int _month;
	int _day;
};
int main()
{
int a =10;               //内置类型的比较
int b =20;
if (a<b){                //这个可以实现
  cout <<"a<b"<<endl ;
}
else if (a>b){
  cout <<"a>b"endl;
}
else{
  cout <<"a==b"<<endl;
}

	Date d1(2021, 10, 11);
	Date d2(d1); //拷贝
 if(d1==d2){   //很直观但是，编译器不知道类应该怎么比较，所以会报错。
               //可以通过运算符重载，就可以直接使用这个。
}

 if(d1.IsEqual(d2))     //调用一个我们写的比较函数，可以实现对象之间的比较。
 {                    
   cout<<"d1==d2"<<endl;
}

	
	d1.operator==(d2); //这里实现了运算符重载可以这么写，也可以直接写下面的形式。
	d1 == d2;//同上，编译器会自动识别转换为d1.operator==(d2); -> d1.operator(&d1, d2);
	return 0;
}

说明:

当我们把函数重载写进类里时，error C2804：operator== 的参数太多了 

这里的矛盾点是运算符重载函数的参数是根据运算符来确定的但是对于类里的函数成员它会有一个 this 指针。解决方法就是少写一个参数。

对于d1 == d2 

编译器会自动识别转换，如果是全局函数那么它会转换成 operator==(d1, d2);；如果是成员函数那么它会转换成 d1.operator(d2);。不管是全局还是成员一般我们都是直接写 d1 == d2。

观察 d1.operator==(d2); 和 d1 == d2; 的汇编代码 

我们不一定需要会写汇编，但是需要勉强看懂
照虎画猫写一个d1<d2 

class Date
{
public:
	Date(int year = 0, int month = 1, int day = 1)
	{
		_year = year;
		_month = month;
		_day = day;	
	}
	bool operator<(const Date& x)//ok
	{
		if(_year < x._year)
			return true;
		else if(_year == x._year && _month < x._month)
			return true;
		else if(_year == x._year && _month == x._month && _day < x._day)
			return true;
		else
			return false;
	}
private:
	int _year;
	int _month;
	int _day;
};
int main()
{
	Date d1(2021, 10, 11);
	Date d2(2020, 11, 11);
	Date d3(2021, 11, 11);
	
	cout << d1 < d2 << endl;//err
	cout << (d1 < d2) << endl;//ok,d1.operator<(d2); -> d1.operator<(&d1, d2);
	return 0;
}

说明:

上面使用 cout 输出结果时，出现了问题。<< 是流插入运算符，它的优先级比较高 (从上面看比 <、= 高，比 () 低)，这里 cout 会先输出 d1，然后再 < 

 注意:

1,不能通过连接其他符号来创建新的操作符：比如 operator@。

 2,重载操作符必须有一个类类型或者枚举类型的操作数。

 3,用于内置类型的操作符，其含义不能改变，例如：内置的整型+，不能改变其含义。

 4,作为类成员的重载函数时，其形参看起来比操作数数目少 1 成员函数的操作符有一个默认的形参 this，限定为第一个形参。

 5， .* 、:: 、sizeof 、?: 、. ，注意以上 5 个运算符不能重载。这个经常在笔试选择题中出现，注意 * 是可以重载的，这里不能重载的是 .*。

 赋值运算符重载
上面我们重载了 == 这个符号，这里我们要重载的是 = 符号。

class Date
{
public:
	Date(int year = 0, int month = 1, int day = 1)
	{
		_year = year;
		_month = month;
		_day = day;	
	}
	void operator=(const Date& x)
	{
		_year = x._year;
		_month = x._month;
		_day = x._day;	
	}
private:
	int _year;
	int _month;
	int _day;
};
int main()
{
	Date d1(2021, 10, 11);
	Date d2(2020, 11, 11);
	Date d3(2021, 11, 11);
	//赋值运算符重载
	d1 = d3;
	//拷贝构造
	Date d4(d3);
	
	Date d5 = d3;//拷贝构造还是赋值运算符重载？？？ ———— 这里是拷贝构造，因为这里是在实例化对象，并且它同 Date d5(d3);
	return 0;
}

 说明:

可以使用拷贝构造替代赋值运算符重载吗?

拷贝构造和赋值运算符重载的场景不一样：

拷贝构造是用于一个对象准备定义时，用另一个对象来初始化它；

赋值运算符重载是用于两个已经定义出来的对象间的拷贝复制。

 对于上面写的赋值运算符重载写的不够好?

 我们说我们去重载运算符，就是控制这个运算符的行为。

1、从赋值运算符的特性来说，它要能支持连续赋值 —— d1 = d2 = d3;。
 

int i = 1;
int j = 2;
int k = 3;
i = j = k;//连续赋值(从右至左),注意连续赋值是有返回值的。这里最后i去接收j=k的返回值

2、d1 = d1 自己赋值给自己，可以，但是没意义，还有可能会破坏之前的拷贝。所以赋值重载中为了防止这种情况它还要控制一下条件。

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


   // 用X 给 this 赋值，加const 保证了安全性，但是没有返回值不能满足 连续赋值。
	void operator=(const Date& x)   
	{
		_year = x._year;
		_month = x._month;
		_day = x._day;			
	}
		

	//因为返回值是Date类型对象this指针。所以
	//d1 = d2 = d3 时，d3赋值给d2，然后的d2赋值给d1.可以实现
    // 用X 给 this 赋值，加const 保证了安全性
	Date& operator=(const Date& x)   
	{
		if(this != &x)
		{
			_year = x._year;
			_month = x._month;
			_day = x._day;			
		}
		
		return *this;
	}
	
private:
	int _year;
	int _month;
	int _day;
};
int main()
{
	Date d1(2022, 3, 21);
	Date d2(2021, 3, 21);
	Date d3(2022, 3, 21);

	d1 = d2 = d3;

	d1 = d1;
	return 0;
}

 说明:

在这里我们再来思考一下，对于this指针为什么仅仅可以在类成员函数{ }里使用 

从上面就可以看出，因为有这样的使用场景。

再看引用价值 

如果使用传值传参，它会再调用拷贝构造，再额外开一块空间。

如果使用传值返回，它不会返回 *this，而是返回一个临时对象 (它也会再调用拷贝构造)。

这时使用引用的价值就有体现了。

注意：

出了作用域 *this 对象不在了，只能用传值返回；但是这里的对象都是在 main 函数里定义的，所以能用引用返回。

 同样如果我们不写赋值重载，编译器也会默认生成 .

类似于拷贝构造函数

1、内置类型成员会完成值拷贝。
2、自定义类型成员会去调用它的赋值重载。

class Time
{
public:
	Time& operator=(const Time& _t)
	{
		cout << "Time& operator=(const Time& _t)" << endl;
		return *this;
	}
};
class Date 
{
public:
	Date(int year = 0, int month = 1, int day = 1)
	{
		_year = year;
		_month = month;
		_day = day;	
	}
	void Print()
	{
		cout << _year << "/" << _month << "/" << _day << endl;
	}
private:
	int _year;
	int _month;
	int _day;

	Time _t;
};
int main()
{
	Date d1(2022, 3, 11);
	d1.Print();
	Date d2(2023, 3, 12);
	
	 
	d1 = d2; //用已存在的d2去构建d1,调用拷贝构造函数，对于_year _month _day 都直接拷贝
	d1.Print();//对于Time_t 要去调用Time类型的拷贝构造函数。
	return 0;
}

小结

对于 6 个默认成员函数，原则：编译器默认生成的能完成我们要的功能就可以不写，不能完成就需要我们自己写。

六、日期类的实现

更深入的学习常见的运算符重载，当然还有一些需要后面的知识铺垫，比如流提取、流插入运算符。

Date.h

#pragma once
#include<iostream>
#include<assert.h>
#include<stdbool.h>
using namespace std;
class Date
{
public:
	//获取某年某月的天数
	int GetMonthDay(int year, int month)
	{
		assert(month > 0 && month < 13);
		//默认平年
		int monthDays[13] = { 0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 };
		//判断润年的二月
		if (month == 2 && ((year % 4 == 0 && year % 100 != 0) || year % 400 == 0))
		{
			return 29;
		}
		return monthDays[month];
	}
	Date(int year = 0, int month = 1, int day = 1)
	{
		_year = year;
		_month = month;
		_day = day;
		//判断日期是否合法
		if (_year < 0 || _month <= 0 || _month >= 13 || _day <= 0 || _day > GetMonthDay(_year, _month))
		{
			cout << _year << "/" << _month << "/" << _day << "->";
			cout << "非法日期" << endl;
		}
	}
	void Print() const
	{
		cout << _year << "/" << _month << "/" << _day << endl;
	}
	bool operator>(const Date& d) const
	{
		if (_year > d._year)
			return true;
		else if (_year == d._year && _month > d._month)
			return true;
		else if (_year == d._year && _month == d._month && _day > d._day)
			return true;
		else
			return false;
	}
	bool operator==(const Date& d) const
	{
		return _year == d._year && _month == d._month && _day == d._day;
	}
	bool operator>=(const Date& d) const
	{
		return *this > d || *this == d;//复用operator>、operator==
	}
	bool operator<(const Date& d) const
	{
		return !(*this >= d);//复用operator>=，再取反
	}
	bool operator<=(const Date& d) const
	{
		return !(*this > d);//复用operator>，再取反
	}
	bool operator!=(const Date& d) const
	{
		return !(*this == d);//复用operator==，再取反	
	}

	Date operator+(int day) const;	
	Date operator-(int day) const;
	Date& operator+=(int day);
	Date& operator-=(int day);
	Date& operator++();
	Date operator++(int);
	Date& operator--();
	Date operator--(int);
	int operator-(const Date& d) const;
private:
	int _year;
	int _month;
	int _day;
};

Date.cpp

#include"Date.h"

Date Date::operator+(int day) const
{
	//Date temp(*this);
	//temp._day += day;
	//while (temp._day > GetMonthDay(temp._year, temp._month))
	//{
	//	temp._day -= GetMonthDay(temp._year,temp._month);
	//	++temp._month;
	//	if (temp._month == 13)
	//	{
	//		++temp._year;
	//		temp._month = 1;
	//	}
	//}
	//return temp;

	//相同逻辑太多，直接复用operator+= (这个比较好)
	Date temp = *this;
	temp += day;
	return temp;
}
Date& Date::operator+=(int day)
{
	if (day < 0)//d1 + -100;
	{
		return *this -= -day;//+= -100到-= 100
	}
	_day += day;
	//日期不合法，需要进位
	while (_day > GetMonthDay(_year, _month))
	{
		_day -= GetMonthDay(_year, _month);
		++_month;
		if (_month == 13)
		{
			++_year;
			_month = 1;
		}
	}
	return *this;

	//相同逻辑太多，直接复用operator+
	//*this = *this + day;
	//return *this;
}
Date Date::operator-(int day) const
{
	Date temp = (*this);
	temp -= day;
	return temp;
}
Date& Date::operator-=(int day)
{
	if (day < 0)
	{
		return *this += -day;
	}
	_day -= day;
	while (_day < 1)
	{
		--_month;
		if (_month == 0)
		{
			--_year;
			_month = 12;
		}
		_day += GetMonthDay(_year, _month);
	}
	return *this;
}
Date& Date::operator++()
{
	*this += 1;//复用operator+=
	return *this;//返回++后的值
}
Date Date::operator++(int)
{
	Date temp = *this;
	*this += 1;//复用operator+=
	return temp;//返回++前的值
}
Date& Date::operator--()
{
	*this -= 1;//复用operator-=
	return *this;//返回--后的值
}
Date Date::operator--(int)
{
	Date temp(*this);
	*this -= 1;//复用operator-=
	return temp;//返回--前的值
}
int Date::operator-(const Date& d) const
{
	//比较大小
	Date max = *this, min = d;
	int flag = 1;
	if (*this < d)
	{
		max = d;
		min = *this;
		flag = -1;
	}

	int n = 0;
	while (min != max)
	{
		++min;//利用operator++()
		++n;
	}
	return n * flag;
}

Test.cpp

#include"Date.h"

void TestDate1()
{
	Date d1(2022, 10, 11);//ok
	Date d2(2022, 2, 29);//err
	Date d3(2021, 2, 29);//ok
	Date d4(2021, 13, 29);//err
}
void TestDate2()
{
	Date d1(2022, 10, 11);
	Date ret;

	ret = d1 + 100;
	ret.Print();

	ret = d1 += 100;
	ret.Print();
	d1.Print();

	ret = d1 + -100;
	ret.Print();
}
void TestDate3()
{
	Date d1(2022, 10, 11);
	Date ret;

	ret = d1 - 11;
	ret.Print();

	ret = d1 -= 11;
	ret.Print();
	d1.Print();

	ret = d1 - -11;
	ret.Print();
}
void TestDate4()
{
	Date d1(2022, 10, 11);
	Date ret;

	ret = ++d1;
	ret.Print();
	d1.Print();

	ret = d1++;
	ret.Print();
	d1.Print();
}
void TestDate5()
{
	Date d1(2022, 10, 11);
	Date ret;

	ret = --d1;
	ret.Print();
	d1.Print();

	ret = d1--;
	ret.Print();
	d1.Print();
}
void TestDate6()
{
	Date d1(2024, 10, 11);
	Date d2(2023, 10, 11);

	cout << d1 - d2 << endl;
	cout << d2 - d1 << endl;
}
int main()
{
	//TestDate1();//日期合法
	//TestDate2();//+、+=、+ -(负)
	//TestDate3();//-、-=、- -(负)
	//TestDate4();//++x、x++
	//TestDate5();//--x、x--
	TestDate6();//d1 - d2
	return 0;
}

说明:

日期的不合法，构造函数有无责任 ？

有的，构造函数不仅仅是完成初始化工作，还要判断数据是否合法。

除了上面说的 5 个运算符不能重载之外，其余的运算符有重载的意义 ？

一个类到底要重载哪些运算符，是看你需要哪些运算符，并且要考量重载的运算符有无价值。

运算符重载 | 函数重载 ？

虽然它们都用了重载这个词，但是它们之间没有关联。

 //前置++  和后置++
	//他们都是单目运算符————只要一个操作数
	//  d1++      ++d1
    //前置++ ：前+1 然后返回+1之后的结果
	Date& operator++()
	{
		_day += 1;
		return *this;

	}
	//后置++：先使用 然后再+1  例如 int a= 10; int b =a++;   b =10; a=11;
	// 后置++中：必须要给*this+1 但是要返回*this加1之前的结果
	//Date& operator++(int )//加这个参数目的让前置++和后置++ 形成重载 ,通过编译。  加了就是后置++
	Date operator++(int)
	{   
		Date temp(*this);
		_day += 1;
		return temp;  //temp是栈上的变量，函数结束栈销毁，所以不能按照引用的方式返回，只能以值的方式返回。
		             
	}
	//前置--
	Date & operator--(){

		_day -= 1;
		return *this;
	}
	//后置--
	Date operator--(int){
		Date temp(*this);
		_day -= 1;
		return temp;
	}

运算符前置++和后置++怎么进行重载(同前置- -和后置- -) 

它们的共同点都是需要 ++ 的，但是它们的返回值不同：前置++ 的返回值是 ++ 以后的；后置++ 的返回值是 ++ 之前的。

这两个运算符都是单操作数，也就是只能有一个 this 指针，按正常的运算符重载规则是无法区分前置与后置的，所以编译器为了能区分这种情况，这里就做了一个特殊的处理 —— 给后置++ 增加一个 int 参数 (这个参数仅仅是为了区分，你给多少它都不会用)，这样它们就能构成函数重载。

日期 - 日期 

常规思路是日减、月减、年减，补它们中间的位，但是实际上实现较难。

思路一：把某月某日映射到 365 天

思路二 (最优)：先比较两日期的大小，然后让小的++，当小的等于大的时，那么加了多少次就是它们相差的天数

七、const成员函数

 const修饰类的成员函数

class Date
{
public:
	Date(int year = 0, int month = 1, int day = 1)
	{
		_year = year;
		_month = month;
		_day = day;
	}
    // 可读可写成员函数
	void Print1()//void Print(const Date* this)//第一个const 表明this的指向，不能修改。
	{                                          // 但是this 指向对象的成员变量，可以修改。
		cout << _year << "/" << _month << "/" << _day << endl;
	}
    //可读成员函数
	void Print2() const//void Print(const Date* const this)//第一个const 表面this的指向， 
                             不能修改。第二个const表明this 指向对象的成员变量，也不能修改。
	{
		cout << _year << "/" << _month << "/" << _day << endl;
	}
    //只读成员函数
    void TestConstFunc()const{  
     Print1();//可以调用 ，TestConstFunc不能修改，新调用的函数也不能修改。
     Print2();//不可以调用，因为TestConstFunc是const类型函数，所以要求this指向对象的成员变量，不能被修改，但是此时调用非const函数，就可能通过这个非const函数，改变对象成员变量的值。不安全。
}
     //可读可写函数
     void TestFunc(){
     Print1();//可以调用， TestFunc原来就可读可写，现在新调函数也可读可写。权限没变
     Print2();//可以调用  TestFunc权限可读可写，新调用的可读，权限安全。
}

private:
	int _year;
	int _month;
	int _day;
};
int main()
{
 // 非const对象 ，它允许其他函数修改自己的成员变量，所以它既可以调用const成员函数，或者非const 
                                                                               成员函数。
	Date d1(2022, 10, 13);
	//Date d2(2022, 10, 14);//ok
	//const Date d2(2021, 10, 14);//err    
	d1.Print1();可以
	d2.Print1();//d2.Print(&d2); 可以

	const Date d3(2021, 10, 14);//ok
	d3.Print2();//d3.Print(&d3);  可以
    d3.print1()//错误

	return 0;
}

总结:

1、成员函数加 const，变成 const 成员函数是有好处的，这样 const 对象可以调用，非 const 对象也可以调用。

2、不是说所有的成员函数都要加 const ，具体要看成员函数的功能，如果成员函数是修改型 (operrato+=、Push)，那就不能加；如果是只读型 (Print、operator+)，那就最好加。

3、const 对象不可以调用非 const 成员函数 (权限放大)；非 const 对象可以调用 const 成员函数 (权限缩小)。

4、const 成员函数内不可以调用其它非 const 成员函数；非 const 成员函数内可以调用其它 const 成员函数。

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

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

	//普通对象取地址 
	/*Date* operator&()
	{
		return this;
	}*/

	//const对象取地址 
	/*const Date* operator&() const
	{
		return this;
	}*/

	Date* operator&()
	{
		return nullptr;
	}
	const Date* operator&() const
	{
		return nullptr;	
	}
	
private:
	int _year;
	int _month;
	int _day;
};
int main()
{
	Date d1(2021, 10, 13);
	const Date d2(2021, 10, 14);

	cout << &d1 << endl; // 写不写都可直接使用
	cout << &d2 << endl; // 写不写都可以直接使用
	return 0;
}

 说明:

一般不需要写，编译器生成的就够用。

如果非要写，比如不想让别人获取对象的地址，就可以自己实现，返回 nullptr。

如果有所收获,还希望大佬能够点攒,关注.