C++类与对象（三）赋值运算符重载、const成员

目录

1.赋值运算符重载

1.1引入

1.2 运算符重载

1.3赋值运算符重载

1.4 前置++和后置++重载

2.const成员

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

---

1.赋值运算符重载

1.1引入

赋值运算符重载：用已存在的对象，给另一个已存在的对象赋值

还是使用上节日期类的代码，在测试中如下操作：

class Date
{
public:
	Date(int year = 2000, 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;
};
void TestDate()
{
	Date d1(2022,11,15);//构造函数
	Date d2(d1);	//拷贝构造函数

	Date d3;//用的默认的参数，创建的时候没给实参
	d3 = d2; //用已存在的对象，给另一个已存在的对象赋值，

	Date d4 = d3;//拷贝构造
}

 语法：如果程序员没有显示定义赋值运算符重载，则编译器会自动生成一份

实际情况：编译器不一定会生成，但是编译器一定会完成赋值的操作

如果类中未涉及到资源管理，赋值运算符是否实现都可以；但是， 一旦涉及到资源管理则必须要实现 ，比如栈的代码，当进行以下操作时：

这时候会出现浅拷贝，导致内存泄漏问题，那么为了解决这个问题，就需要使用 赋值运算符重载方法，下面依次进行学习

1.2 运算符重载

还是从代码来学习：

需求：检测两个日期类型对象是否相等（用的还是上面日期类代码，修改部分如下）

	//需求：检测两个日期类型对象是否相等
	bool IsEqual(const Date& d)
	{
		return _year == d._year &&
		_month == d._month &&
		_day == d._day;
	}

int main()
{
	Date d1(2022, 11, 15);
	Date d2(d1);
	if (d1.IsEqual(d2))
	{
		cout << "d1 == d2" << endl;
	}
	else
	{
		cout << "d1 != d2" << endl;
	}


//上面不直观，要是使用==如下
if (d1==d2)
	{
		cout << "d1 == d2" << endl;
	}
	else
	{
		cout << "d1 != d2" << endl;
	}

	return 0;
}

使用==会报错，所以注意，自定义类型不支持 == 的运算符，因为编辑器不知道怎么比较

如果一定要使用 == 来比较自定义类型对象， 必须告诉编译器比较的规则--->运算符重载

修改上述代码

bool operator==(const Date& d)
	{
		return _year == d._year &&
			_month == d._month &&
			_day == d._day;
	}

if (d1==d2)//与if(d1.operator(d2))等价
	{
		cout << "d1 == d2" << endl;
	}
	else
	{
		cout << "d1 != d2" << endl;
	}

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

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

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

注意：

1.在operator后面跟的必须是C++支持的运算符，不能通过连接其他符号来创建新的操作符：比如operator@，

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

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

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

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

1.3赋值运算符重载

1. 赋值运算符重载格式

参数类型：const T&，传递引用可以提高传参效率

返回值类型：T&，返回引用可以提高返回的效率，有返回值目的是为了支持连续赋值

检测是否自己给自己赋值

返回*this ：要复合连续赋值的含义

Date& operator=(const Date& d)
 {
     if(this != &d)
     {
     _year = d._year;
     _month = d._month;
     _day = d._day;
     }
     return *this;
 }

2. 赋值运算符只能重载成类的成员函数不能重载成全局函数

原因：赋值运算符如果不显式实现，编译器会生成一个默认的。此时用户再在类外自己实现一个全局的 赋值运算符重载，就和编译器在类中生成的默认赋值运算符重载冲突了，故赋值运算符重载只能是类的成员函数

3. 用户没有显式实现时，编译器会生成一个默认赋值运算符重载，以值的方式逐字节拷贝。注意：内置类 型成员变量是直接赋值的，而自定义类型成员变量需要调用对应类的赋值运算符重载完成赋值

1.4 前置++和后置++重载

// 前置 ++ ：返回 +1 之后的结果

// 注意： this 指向的对象函数结束后不会销毁，故以引用方式返回提高效率

Date& operator++()
 {
 _day += 1;
 return *this;
 }

// 后置++：

// 前置 ++ 和后置 ++ 都是一元运算符，为了让前置 ++ 与后置 ++ 形成能正确重载

// C++ 规定：后置 ++ 重载时 多增加一个int类型的参数 ， 但调用函数时该参数不用传递，编译器自动传 递

// 注意：后置 ++ 是先使用后 +1 ，因此需要返回 +1 之前的旧值，故需在实现时需要先将 this 保存一份，然后给this+1

// 而 temp 是临时对象，因此只能以值的方式返回，不能返回引用

Date operator++(int)
 {
 Date temp(*this);
 _day += 1;
 return temp;
 }

int main()
{
 Date d;
 Date d1(2022, 1, 13);
 d = d1++; // d: 2022,1,13 d1:2022,1,14
 d = ++d1; // d: 2022,1,15 d1:2022,1,15
 return 0;
}

2.const成员

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

A.普通成员函数：没有被const修饰的成员函数

在该成员函数中，可以对对象成员变量进行修改

this类型：Date*  const  ----》this的指向不能修改，this指向空间的内容可以修改

可写入：可以修改成员变量

void show()
	{
		_day += 1;
		this->_day += 1; //与上面等价

		cout << _year << "/" << _month << "/" << _day << endl;
	}

B const成员函数：被const修饰的成员函数

特性：不能修改“成员变量”

const修饰成员函数实际实在修饰this指针

this的类型：const Date* const

只读：只能读取this中成员，不能修改

注意：如果成员函数内部不一定会修改成员变量，最后将该成员设置const函数

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

    void show()
	{
		_day += 1;
		this->_day += 1; //与上面等价

		cout << _year << "/" << _month << "/" << _day << endl;
	}
	//const成员函数：被const修饰的成员函数
	//特性：不能修改“成员变量”
	//const修饰成员函数实际实在修饰this指针
	//this的类型：const Date* const
	void Print()const
	{
		cout << _year << "/" << _month << "/" << _day << endl;
	}

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


int main()
{
	//普通对象d1可读可写，既可以调用普通成员函数也可以调用const成员函数
	Date d1(20022, 12, 2);
	d1.show();
	d1.Print();

	//const对象d2只读，只能调用const成员函数，只读不能写
	const Date d2(d1);
	d2.Print();
	return 0;
}

请思考下面的几个问题：

1. const对象可以调用非const成员函数吗？

const对象不能修改调用普通成员函数

2. 非const对象可以调用const成员函数吗？

可以

3. const成员函数内可以调用其它的非const成员函数吗？

不可以

4. 非const成员函数内可以调用其它的const成员函数吗？

可以

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

class Date
{ 
public :
 Date* operator&()
 {
 return this ;
 }
 
//this的类型就是const Date* const
 const Date* operator&()const
 {
 return this ;
 }
private :
 int _year ; // 年
 int _month ; // 月
 int _day ; // 日
};
int main()
{
	
	Date d1(20022, 12, 2);
	
	//需求：在对对象取地址的时候需要将地址打印出来
	Date* p = &d1;

	
	return 0;
}

这两个运算符一般不需要重载，使用编译器生成的默认取地址的重载即可，只有特殊情况，才需要重载，比如想让别人获取到指定的内容