【C++初阶】第三站:类和对象(中) -- 类的6个默认成员函数

前言

类的6个默认成员函数

构造函数

概念

特性

析构函数

概念

特性

拷贝构造函数

概念

特征

赋值运算符重载

运算符重载

赋值运算符重载

const成员

const修饰类成员函数

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

本章总结：

前言

有时候我们写好了一个栈，头脑中第一件事情就会先去，Push压栈，各种操作，经常会忘掉一件事情--初始化，当忘记初始化栈的时候，那就会引发程序的崩溃：

还有还可能忘记释放之前申请的空间，引发内存泄露问题。那C++中有没有新的语法，可以帮助我们自动调用函数呢？引出我们的构造函数。

类的6个默认成员函数

        如果一个类中什么成员都没有，简称为空类。
        空类中真的什么都没有吗？并不是，任何类在什么都不写时，编译器会自动生成以下6个默认成员函数。
        默认成员函数：用户没有显式实现，编译器会生成的成员函数称为默认成员函数

构造函数

概念

对于以下Date类：

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

class Date

{

public :

        void Init ( int year , int month , int day )

        {
               _year = year ;

                _month = month ;

                _day = day ;

        }

        void Print ()

        {

                cout << _year << "-" << _month << "-" << _day << endl ;

        }

private :

        int _year ;

        int _month ;

        int _day ;

};

int main ()

{

        Date d1 ;

        d1 . Init ( 2022 , 7 , 5 );//创建对象d1之后，需要调用这个初始化函数对d1对象进行初始化

        d1 . Print ();



        Date d2 ;

        d2 . Init ( 2022 , 7 , 6 );//这样未免有点太麻烦了

        d2 . Print ();

        return 0 ;

}

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

特性

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

1. 函数名与类名相同。

2. 无返回值。

        解析:函数名前面无数据类型，不需要写void,

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

        解析:当创建一个对象的时候，编译器会自动调用该类的构造函数对新创建的变量进行初始化

4. 构造函数可以重载

        解析:本质就是我们写多个构造函数，提供多种初始化方式

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

注意，并不是我们不写，编译器默认生成的构造函数才被叫做默认构造函数，

以下三种都可以称为默认构造函数：

        1.无参构造函数

        2.全缺省构造函数

        3.我们没写编译器默认生成的构造函数

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

解释特性3：对象实例化时编译器自动调用对应的构造函数。

代码示例：

根据函数缺省的知识，可以将上面的无参构造和带参构造的写法合并，写成 全缺省构造函数：
还要注意的是构造函数 不能写成这样:

这样写的话，编译器不知道是定义对象，还是声明一个函数
Date d1();   
// 注意：如果通过无参构造函数创建对象时，对象后面不用跟括号，否则就成了函数声明
// 以下代码的函数：声明了d3函数，该函数无参，返回一个日期类型的对象
// warning C4930: “Date d3(void)”: 未调用原型函数(是否是有意用变量定义的?)

解释特性4：构造函数可以重载

在面向对象编程中，一个类可以根据实际需要定义多个构造函数，这些构造函数的名称都与类名相同，但参数列表不同（参数的数量、类型或顺序各异）。这样设计的好处在于，创建该类的对象时，可以根据实际提供的参数来选择调用哪个构造函数进行初始化。

所以构造函数建议写成全缺省的构造函数，这样的话，无论传参个数的多少，都能适用。

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

还有另一种情况是将全缺省改成半缺省：

测试代码

class Date
{
public:
	//情况1，(以下没有注释)如果用户显式定义了构造函数，编译器将不再生成
	Date(int year, int month, int day)
	{
	_year = year;
	_month = month;
	_day = day;
	}
	//情况2，全缺省改成半缺省
	Date(int year , int month = 1, int day = 1)
	{
		cout << "Date(int year =1,int month = 1.int day = 1)" << endl;
		_year = year;
		_month = month;
		_day = day;
	}
	void Print()
	{
		cout << _year << "/" << _month << "/" << _day << endl;
	}

private:
	int _year;
	int _month;
	int _day;
};

int main()
{
		// 无参构造函数，放开后报错：error C2512: “Date”: 没有合适的默认构造函数可用
	Date d1;
	d1.Print();
	return 0;
}

关于编译器生成的默认成员函数，很多初学者会有疑惑： 不实现构造函数的情况下，编译器会生成默认的构造函数。 但是看起来默认构造函数又没什么用？d对象调用了编译器生成的默认构造函数，但是 d对象_year/_month/_day，依旧是随机值。也就说在这里编译器生成的默认构造函数并没有什么用？

解答：C++把类型分成 内置类型(基本类型) 和 自定义类型 。

内置类型就是语言提供的数据类型，如：int/char...
自定义类型就是我们使用class/struct/union等自己定义的类型

看看下面的程序，就会发现编译器生成默认的构造函数会对自定类型成员_t调用的它的默认成员函数。

以上是对于日期类的情况，对于栈类，也是同样道理，自定义类型的成员才会处理，会去调用这个成员的默认构造函数

栈的构造函数的应用，用C++实现栈：

class Stack
{
public:
	//Stack()
	//{
	//	a = nullptr;
	//	top = capacity = 0;//栈顶元素的下一个位置
	//}

//优化后的构造函数
	Stack(size_t n = 4)//优化的写法
	{
		if (n == 0)
		{
			a = nullptr;
			top = capacity = 0;
		}
		else
		{
			a = (int*)malloc(sizeof(int) * n);
			if (a == nullptr)
			{
				perror("realloc fail");
				exit(-1);
			}
			top = 0;
			capacity = n;
		}
	}
	//void Init()
	//{
	//	a = nullptr;
	//	top = capacity = 0;
	//}
	void Push(int x)
	{
		if (top == capacity)
		{
			size_t newcapacity = capacity == 0 ? 4 : capacity * 2;
			int* tmp = (int*)realloc(a, sizeof(int) * newcapacity);
			//tmp 会指向新的内存区域（如果发生迁移），否则它仍指向原内存区域（如果没有迁移）。
			///无论是否发生迁移，原有的指针 a 应该被 tmp 替代，
			//以确保后续操作使用的都是正确且可能已改变的内存地址：
			if (tmp == nullptr)
			{
				perror("realloc fail");
				exit(-1);//以异常的方式退出
			}
			if (tmp == a)
			{
				cout << capacity << "原地扩容" << endl;
			}
			else
			{
				cout << capacity << "异地扩容" << endl;
			}
			a = tmp;
			capacity = newcapacity;
		}
		a[top++] = x;
	}
	int Top()
	{
		return a[top - 1];
	}
	void Pop()
	{
		assert(top > 0);
		--top;
	}
	void Destroy()
	{
		free(a);
		a = nullptr;
		top = capacity = 0;
	}
	bool Empty()
	{
		return top == 0;
	}
	
private:
	//成员变量 
	int* a;//指针都是内置类型
	int top;
	int capacity;
};
int main()
{
	Stack st1;//使用栈的构造函数的默认初始值
	//st1.Init();
	st1.Push(1);
	st1.Push(2);
	st1.Push(3);
	st1.Push(4);
	while (!st1.Empty())
	{
		cout << st1.Top() << " ";
		st1.Pop();
	}
	cout << endl;
	st1.Destroy();
	
//直接写这种 -- 优化的写法
    Stack st2(0);//可以自定义初始化栈的数据 
	for (size_t i = 0; i < 1000; i++)
	{
		st2.Push(i);
	}
	while (!st2.Empty())
	{
		cout << st2.Top() << " ";
		st2.Pop();
	}
	cout << endl;
	st2.Destroy();
}

C++11中，声明支持给缺省值，如果声明有缺省值，才会处理，但一般的内置类型的成员不会处理

注意：C++11 中针对内置类型成员不初始化的缺陷，又打了补丁，即：内置类型成员变量在

类中声明时可以给默认值。

演示：

/
class Date
{
public:
//以下Date构造函数注释掉
	/*Date(int year=1 , int month = 1, int day = 1)
	{
		cout << "Date(int year =1,int month = 1.int day = 1)" << endl;
		_year = year;
		_month = month;
		_day = day;
	}*/
	void Print()
	{
		cout << _year << "/" << _month << "/" << _day;
	}
private:
	int _year =1;//这里给值是声明，不是初始化，因为初始化的特征是开空间，这里并没有开空间
	int _month ;
	int _day ;

};
int main()
{
	Date d1;//我们没写，编译器自动调用默认生成的构造函数，我们在声明的_year处给了初始值，所以    只有这个地方是赋值的，其他地方都是随机数
	d1.Print();
}

解释特性6：无参的构造函数和全缺省的构造函数都称为默认构造函数，并且默认构造函数只能有一个。

注意：无参构造函数、全缺省构造函数、我们没写编译器默认生成的构造函数，都可以认为是默认构造函数（特点:不传参就可以调用的构造就是默认构造）。

刚刚我们提到，对于日期类，多个构造函数(无参的、有参的)并存会存在调用二义性，所以三个默认的构造函数中，只能存在一个：

并且如果构造函数是有参的，则不能缺任何一个初始化的形参值，比如：

对于栈类实例化对象来说，不对n初始化，虽然这里给了值，但不视为全缺省参数，又因为我们实现了这个Stack类的构造函数，所以说，不能视为无参构造函数和编译器默认生成的构造函数。

总结:

一般情况都需要我们自己写构造函数，决定初始化方式

如果成员变量全是自定义类型，可以考虑不写构造函数

构造函数的应用：

之前我们写过的一个有效的括号的题目:有效的括号--c语言实现

现在经过了C++改良后，栈的初始化以及销毁部分就通通有编译器实现了：

代码实现(栈的实现在上文构造函数的应用)：
bool isValid(const char* s) {
	Stack st;
	while (*s)
	{
		if (*s == '[' || *s == '(' || *s == '{')
		{
			st.Push(*s);
			++s;
		}
		else
		{
			// 不匹配
			if (st.Empty())
				return false;

			char top = st.Top();
			st.Pop();

			// 不匹配
			if ((*s == ']' && top != '[')
				|| (*s == ')' && top != '(')
				|| (*s == '}' && top == '{'))
			{
				return false;
			}
			
			++s;
		}
	}

	return st.Empty();
}
int main()
{
	cout << isValid("[[]]()()") << endl;
	cout << isValid("[[]]]") << endl;

	return 0;
}

析构函数

概念

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

特性

析构函数是特殊的成员函数，其特征如下：

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

#日期类的构造函数和析构函数
class Date
{
public:
	Date()//构造函数
	{}
	~Date()//析构函数
	{}
private:
	int _year ;
	int _month ;
	int _day ;
};

#栈类的构造函数和析构函数
class Stack
{
public:
	Stack()
	{}
	~Stack()
	{}
private:
	int* a;
	int top;
	int capacity;
};

2. 无参数无返回值类型。.

函数名(跟类名相同)前不用写返回值(意味着void不用写)，不用传入参数

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

在C++中，每个类对象都有一个生命周期。当对象的生命周期到达终点（如离开作用域或动态分配的对象被删除时），C++编译系统会自动调用该对象的析构函数。析构函数是一个特殊成员函数，它的主要职责是在对象销毁前进行必要的清理工作，如释放内存、关闭文件或解除其他系统资源的占用，以确保程序运行的健壮性和资源的有效管理。

4. 一个类只能有一个析构函数。若未显式定义，系统会自动生成默认的析构函数。注意：析构函数不能重载

编译器自动生成的析构函数机制:

对于日期类，成员变量是_year、_month、_day(内置类型)，是属于d1对象的，这个对象在栈帧里面，栈帧出了作用域自动就销毁了，所以是不需要销毁的，日期类都不用写析构函数

对于栈类(自定义类型)，是需要写析构函数的，但不用写Destroy()函数了,因为有析构函数就行了，它的作用就是清理资源，何为资源：malloc、fopen(动态)等

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

class Stack
{
public:
    Stack(size_t n=10)
    {
		if (n == 0)
	    {
		    a = nullptr;
			top = capacity = 0;
		}
		else
		{
			a = (int*)malloc(sizeof(int) * n);
			if (a == nullptr)
			{
				perror("realloc fail");
				exit(-1);
			}
		top = 0;
		capacity = n;
	     }
	}
	~Stack()
	{
		cout << "~Stack()" << endl;
		free(a);
		a = nullptr;
		top = capacity = 0;
	}
private:
	//成员变量 
	int* a;
	int top;
	int capacity;
};
class MyQueue
{
private:
	Stack _pushst;
	Stack _popst;
};
int main()
{
	MyQueue mq;
}

6.先构造的后析构，后构造的先析构

观察：

拷贝构造函数

概念

在创建对象时，可否创建一个与已存在对象一某一样的新对象呢？

int main()
{
	Date d1(2023, 7, 21);
	Date d2(d1);
//	Date d2 = d1;//等价上面的写法
 
    return 0;
}

拷贝构造函数：只有单个形参，该形参是对本类类型对象的引用(一般常用const修饰)，在用已存
在的类类型对象创建新对象时由编译器自动调用

特征

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

解释特性1：拷贝构造函数是构造函数的一个重载形式。

代码：

时间类拷贝构造：
Date(Date& d)
{
		cout << "Date(Date& d)" << endl;

		_year = d._year;
		_month = d._month;
		_day = d._day;
}
栈类拷贝构造 ：
Stack(const Stack& s)
{
		cout << "Stack(Stack& s)" << endl;
		//深拷贝
		_array = (DataType*)malloc(sizeof(DataType) * s._capacity);
		if (NULL == _array)
		{
			perror("malloc申请空间失败!!");
			return;
		}
		memcpy(_array, s._array, sizeof(DataType) * s._size);
		_size = s._size;
		_capacity = s._capacity;
}

解释：主要负责在创建新对象时，以已存在的同类型对象作为参数，进行初始化工作。当一个对象通过值传递或直接使用另一个对象来初始化时，编译器会自动调用拷贝构造函数。这个特化的过程确保了新对象与原有对象具有相同的内部状态和属性，实现了对象的深复制或浅复制行为。因此，拷贝构造函数是一种对常规构造函数功能的重要补充和扩展，专门用于处理对象间的拷贝操作。

解释特性2:拷贝构造函数的参数只有一个且必须是类类型对象的引用，使用传值方式编译器直接报错，因为会引发无穷递归调用

举一个代码例子：

class Date
{
public:
	Date(int year = 1, int month = 1, int day = 1)
	{
		_year = year;
		_month = month;
		_day = day;
	}
	//Date d2(d1);
	Date(Date d)//用一个对象接收，形参是实参的一份临时拷贝
	{
		cout << "Date(Date& d)" << endl;
		_year = d._year;
		_month = d._month;
		_day = d._day;
	}
	void Print()
	{
		cout << _year << "/" << _month << "/" << _day << endl;
	}
private:
	// 内置类型
	int _year;
	int _month;
	int _day;
};
int main()
{
	Date d1;
	Date d2(d1);//Date d2 = d1;
	
	return 0;
}

图解：

自定义类型传值传参必须要调用拷贝构造，自定义类型传参是一种对象间的拷贝初始化，要调用拷贝构造才能完成这个过程:①要调用拷贝构造,就得先传参。②使用传值传参的方式，导致对象间拷贝，拷贝引发拷贝构造函数的调用。③若调用拷贝函数，得先传值传参，接着又形成拷贝构造。

问：传值传参引发对象拷贝之后，为什么要调用拷贝构造函数？

        为了正确地初始化新创建的对象，该对象是对传值参数的副本。

        在传值传参过程中，系统需要分配新的内存空间并把原对象的状态完整复制到新对象中。拷贝构造函数就是专门设计用来执行这种对象间复制操作的，确保新对象与原始对象具有相同的内部状态。

        通过调用拷贝构造函数可以实现深拷贝或浅拷贝，并处理可能存在的资源管理问题（如动态分配的内存、文件句柄等）。

那这时候我们应该使用引用类型接收，因为引用只是同一块空间的别名，不会引发拷贝问题

Date(const Date& d)//加上const的原因是防止有人把d的位置写到左边去
{
	cout << "Date(Date& d)" << endl;
	_year = d._year;
	_month = d._month;
	_day = d._day;
}

解释特性3：若未显式定义，编译器会生成默认的拷贝构造默认的拷贝构造函数对象按内存存储按字节序完成拷贝，这种拷贝叫做浅拷贝，或者值拷贝

class Date
{
public:
	Date(int year = 1, int month = 1, int day = 1)//默认构造函数
	{
		_year = year;
		_month = month;
		_day = day;
	}
//拷贝构造函数
	//Date d2(d1);
	//Date(const Date& d)
	//{
	//	cout << "Date(Date& d)" << endl;
	//	_year = d._year;
	//	_month = d._month;
	//	_day = d._day;
	//}

	void Print()
	{
		cout << _year << "/" << _month << "/" << _day << endl;
	}
	
private:
	// 内置类型
	int _year;
	int _month;
	int _day;
};
void func1(Date d)
{
	d.Print();
}
int main()
{
	Date d1;
	Date d2(d1);//1
	func1(d2);//2
	d2.Print();
	return 0;
}

执行：

上段代码调用了两次拷贝构造，可是我们并没有实现拷贝构造函数的代码编写，由此得知，编译器自动调用了拷贝构造函数完成了对象的拷贝。

我们由上文可知，编译器默认生成的拷贝构造，跟之前的拷贝函数特性不一样

默认构造、析构函数:

对于内置类型的成员不会处理，而自定义类型的成员才会处理，会去调用这个成员的默认构造函数。

总结：一般情况都需要我们自己写构造函数，决定初始化方式

成员变量全是自定义类型，可以考虑不写构造函数

拷贝构造函数：

1.内置类型，值拷贝
2.自定义类型，调用他的拷贝

解释特性4：编译器自动生成的拷贝构造函数不能实现深拷贝

由上文可知

在编译器生成的默认拷贝构造函数中，内置类型是按照字节方式直接拷贝的，也就说值拷贝，值拷贝(浅拷贝)的意思是把对象里面的所有成员函数以及它们的值，一个一个、完完全全地赋值给另一个对象。

Date d1;
Date d2(d1);//用已存在的对象d1创建对象d2
//  || 等价于
//Date d2 = d1;

但是值拷贝，在某些场景下可能会引发程序错误:

typedef int DataType;
class Stack
{
public:
	Stack(size_t capacity = 3)//默认构造函数
	{
		_array = (DataType*)malloc(sizeof(DataType) * capacity);
		if (NULL == _array)
		{
			perror("malloc申请空间失败!!!");
			return;
		}

		_capacity = capacity;
		_size = 0;
	}
    void Push(DataType data)
	{
		// CheckCapacity();
		_array[_size] = data;
		_size++;
	}
	void Print()
    {
        cout<<_array<<endl;
    }
private:
	// 内置类型
	DataType* _array;
	int _capacity;
	int _size;
};
int main()
{
	Stack s1;
	s1.Print();
	Stack s2(s1);
	s2.Print();
    return 0;
}

执行：

C语言的拷贝为值拷贝，会导致两个对象指向同一块空间的问题，C++兼容C语言，如果按照正常C语言的思路写，那么也是浅拷贝

两对象指向的地址是一样的，当两对象的生命周期结束时自动调用析构函数，也就意味着s2先调用析构，s1后调用析构，这时候s1访问这块空间会出现野指针访问异常的问题，因为同一块空间，被释放了两次，等到第二次析构时，s2指针指向了一块已经归还给操作系统的空间。

用同一个对象去拷贝另一个对象的时候呢，这里用了拷贝构造函数去解决这个问题(深拷贝)

下面这个代码使用引用接收的原因，是因为引用只是对象s1的别名,属于同一块空间，假设使用值接收，就会引发无穷递归问题。

Stack(const Stack& s)
	{
		cout << "Stack(Stack& s)" << endl;
		// 深拷贝
		_array = (DataType*)malloc(sizeof(DataType) * s._capacity);
		if (NULL == _array)
		{
			perror("malloc申请空间失败!!!");
			return;
		}
            //destination   source
		memcpy(_array, s._array, sizeof(DataType) * s._size);
		_size = s._size;
		_capacity = s._capacity;
	}
int main()
{
	Stack s1;
	s1.Print();
	Stack s2(s1);
	s2.Print();
    return 0;
}

所以注意：类中如果没有涉及资源申请时，拷贝构造函数是否写都可以；一旦涉及到资源申请 时，则拷贝构造函数是一定要写的，否则就是浅拷贝。

总结一下：

1.像Date类不需要我们写拷贝构造，默认生成就可以用
2.像Stack类需要我们自己实现深拷贝的拷贝构造，默认生成会出问题

解释特性5：拷贝构造函数典型调用场景

1️⃣使用已存在对象创建新对象

2️⃣函数参数类型为类类型对象

3️⃣函数返回值类型为类类型对象

测试代码：

class Date
{
public:
	Date(int year, int minute, int day)
	{
		cout << "Date(int,int,int):" << this << endl;
	}
	Date(const Date& d)
	{
		cout << "Date(const Date& d):" << this << endl;
	}
	~Date()
	{
		cout << "~Date():" << this << endl;
	}
private:
	int _year;
	int _month;
	int _day;
};
Date Test(Date d)
{
	Date temp(d);
	return temp;
}
int main()
{
	Date d1(2022, 1, 13);
	Test(d1);
	return 0;
}

代码执行：

为了提高程序效率，一般对象传参时，尽量使用引用类型，返回时根据实际场景，能用引用

尽量使用引用。

赋值运算符重载

运算符重载

概念：自定义类型不支持比较，是因为写了运算符重载才支持比较

C++为了增强代码的可读性引入了运算符重载，运算符重载是具有特殊函数名的函数，也具有

其返回值类型，函数名字以及参数列表，其返回值类型与参数列表与普通的函数类似。
函数名字为：关键字 operator 后面接需要重载的运算符符号。
函数原型：返回值类型 operator操作符(参数列表)

特性

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

2.重载操作符必须有一个类类型参数

3.用于内置类型的运算符，其含义不能改变，例如：内置的整型+，不能改变其含义

4.作为类成员函数重载时，其形参看起来比操作数数目少1，因为成员函数的第一个参数为隐藏的this

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

自定义类型与内置类型的区别：

==运算符在Date类中重载

代码如下：

class Date
{
public:
	Date(int year = 1, int month = 1, int day = 1)
	{
		_year = year;
		_month = month;
		_day = day;
	}
	bool operator==(const Date& d)
	{
		return _year == d._year
			&& _month == d._month
			&& _day == d._day;
	}
	void Print()
	{
		cout << _year << "/" << _month << "/" << _day << endl;
	}
private:
	int _year;
	int _month;
	int _day;
};
int main()
{
	Date d1(2024, 1, 1);
	Date d2(2024, 1, 1);
	cout << (d1 == d2) << endl;
    //等价于(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;
	}
	void Print()
	{
		cout << _year << "/" << _month << "/" << _day<<endl;
	}
private:
	int _year;
	int _month;
	int _day;
};
int main()
{
	Date d1;
	d1.Print();
	Date d2(2024, 1, 1);
	d2.Print();
	d1 = d2;
	d1.Print();
	d2.Print();
}

关于赋值运算符需要注意以下5点:

赋值运算符重载格式

参数类型：const T&，传递引用可以提高传参效率
返回值类型：T&，返回引用可以提高返回的效率，有返回值目的是为了支持连续赋值
检测是否自己给自己赋值
返回*this ：要复合连续赋值的含义
用户没有显式实现时，编译器会生成一个默认赋值运算符重载，以值的方式逐字节拷贝

既然编译器生成的默认赋值运算符重载函数已经可以完成字节序的值拷贝了，还需要自己实

现吗？当然像日期类这样的类是没必要的。那么下面的类呢？验证一下试试？

typedef int DataType;
class Stack
{
public:
   Stack(size_t capacity = 10)
   {
       _array = (DataType*)malloc(capacity * sizeof(DataType));
       if (nullptr == _array)
       {
           perror("malloc申请空间失败");
           return;
       }
       _size = 0;
       _capacity = capacity;
   }
   void Push(const DataType& data)
   {
       // CheckCapacity();
       _array[_size] = data;
       _size++;
   }
   ~Stack()
   {
       if (_array)
       {
           free(_array);
           _array = nullptr;
           _capacity = 0;
           _size = 0;
       }
   }
private:
   DataType* _array;
   size_t _size;
   size_t _capacity;
};
int main()
{
   Stack s1;
   s1.Push(1);
   s1.Push(2);
   s1.Push(3);
   s1.Push(4);
   Stack s2;
   s2 = s1;
   return 0;
}

注意：如果类中未涉及到资源管理，赋值运算符是否实现都可以；一旦涉及到资源管理则必

须要实现。

区分以下代码：

Date d1(2024, 1, 1);

Date d2(d1);

Date d3 = d1;

Date d1(2024, 1, 1)调用的是构造函数; Date d2(d1)调用的是拷贝构造函数。Date d3 = d1;注意：不是是赋值运算符重载函数，第三句代码也是拷贝构造函数。

注意区分拷贝构造函数和赋值运算符重载函数的使用场景：

拷贝构造函数：用一个已经存在的对象去构造初始化另一个即将创建的对象。
赋值运算符重载函数：在两个对象都已经存在的情况下，将一个对象赋值给另一个对象。

图解：

const成员

const修饰类成员函数

将const修饰的“成员函数”称之为const成员函数，const修饰类成员函数，实际修饰该成员函数
隐含的this指针，表明在该成员函数中不能对类的任何成员进行修改。

代码如下：

class Date
{
public:
	Date(int year, int month, int day)
	{
		_year = year;
		_month = month;
		_day = day;
	}
	void Print()
	{
		cout << "Print()" << endl;
		cout << "year:" << _year << endl;
		cout << "month:" << _month << endl;
		cout << "day:" << _day << endl << endl;
	}
	void Print() const
	{
		cout << "Print()const" << endl;
		cout << "year:" << _year << endl;
		cout << "month:" << _month << endl;
		cout << "day:" << _day << endl << endl;
	}
private:
	int _year; // 年
	int _month; // 月
	int _day; // 日
};
int main()
{
	Date d1(2022, 1, 13);
	d1.Print();
	const Date d2(2022, 1, 13);
	d2.Print();
}

请思考下面的几个问题：

1.const对象可以调用非const成员函数吗？
不可以，因为const修饰的对象为只读类型，若调用非const成员函数,属于权限放大行为，只读权限变成既可以只读又可以可写。

2.非const对象可以调用const成员函数吗？
可以，因为非const对象权限拥有可读、可写权限，调用const成员函数属于权限缩小问题，权限变为只读。

3.const成员函数内可以调用其它的非const成员函数吗？
不可以，因为const修饰的成员函数为只读类型，若调用非const非成员函数,属于权限放大行为，只读权限变成既可以只读又可以可写。

4.非const成员函数内可以调用其它的const成员函数吗？
可以，因为非const成员函数权限拥有可读、可写权限，调用const成员函数属于权限缩小问题，权限变为只读。

总结：权限只可以缩小，不能够放大。也就是我本身只能是可读的(const)，不能传过去编程可读可写的了(非const)

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

这两个默认成员函数一般不用重新定义，编译器默认会生成。 

代码如下：

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

这两个运算符一般不需要重载，使用编译器生成的默认取地址的重载即可，只有特殊情况，才需

要重载，比如想让别人获取到指定的内容！