类和对象（2）——赋值运算符重载

最新推荐文章于 2024-04-14 22:44:44 发布

L_AITY.

最新推荐文章于 2024-04-14 22:44:44 发布

阅读量1k

点赞数

分类专栏：类和对象文章标签： c++ 开发语言

本文链接：https://blog.csdn.net/qq_48042235/article/details/128018732

版权

类和对象专栏收录该内容

9 篇文章 0 订阅

订阅专栏

1.1 运算符重载

1.2 赋值运算符重载

1.3 前置++和后置++重载

1.1 运算符重载

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

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

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

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

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

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

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

（5）.* :: sizeof ?: . 注意以上5个运算符不能重载

例：判断两个对象是否相等，就需要重载==运算符

class Date
{
public:
	Date(int year = 0, int month = 0, int day = 0)
	{
		_year = year;
		_month = month;
		_day = day;
	}
	bool operator==(const Date& d)
	{
		return _year == d._year&&
				_month==d._month&&
				_day==d._day;	
	}

private:
	int _year;
	int _month;
	int _day;	
};
 int main()
 {
	 Date d1(2022,11, 20);
	 Date d2(d1);
	 d2 ==d1;
 }

1.2 赋值运算符重载

1.赋值运算符重载格式：

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

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

检测是否自己给自己赋值

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

class Date
{
public:
	Date(int year = 0, int month = 0, int day = 0)
	{
		_year = year;
		_month = month;
		_day = day;
	}
	bool operator==(const Date& d)
	{
		return _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;
};
int main()
{
	Date d1(2022, 11, 20);
	Date d2;
	Date d3;
	d3 = d2 = d1;
}

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

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

	int _year;
	int _month;
	int _day;
};
Date& operator=( Date& left,const Date& right)  //编译失败
{
	if (&left != &right)
	{
		left._year = right._year;
		left._month = right._month;
		left._day = right._day;
	}
	return left;
}

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

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

class Time
{
public:
	Time()
	{
		_hour = 1;
		_minute = 1;
		_second = 1;
	}
	Time& operator=(const Time& t)
	{
		if (this != &t)
		{
			_hour = t._hour;
			_minute = t._minute;
			_second = t._second;
		}
		return *this;
	}
private:
	int _hour;
	int _minute;
	int _second;
};
class Date
{
private:
	// 基本类型(内置类型)
	int _year = 1970;
	int _month = 1;
	int _day = 1;
	// 自定义类型
	Time _t;
};
int main()
{
	Date d1;
	Date d2;
	d1 = d2;
	return 0;
}

可以看出，Date类没有显式定义赋值运算符重载，Date类在编译时，编译器会生成一个默认的赋值运算符重载给内置类型直接赋值，而给自定义类型赋值时，必须调用相关类的赋值运算符重载去完成。

4.如果类中未涉及到资源管理，赋值运算符是否实现都可以；一旦涉及到资源管理则必须要实现。

例如：栈（stack)类，用一个s1对象给另一个s2对象赋值，若没有显示定义赋值运算符重载，则编译器默认生成，采用浅拷贝的方式来赋值，则会使s1和s2共享同一份内存空间。在销毁时，空间被销毁两次，会发生错误。

1.3 前置++和后置++重载

class Date
{
public:
	Date(int year = 0, int month = 0, int day = 0)
	{
		_year = year;
		_month = month;
		_day = day;
	}
	//前置++重载，返回+1后的结果
	Date& operator++()
	{
		_day += 1;
		return *this;
	}
	//后置++重载，返回+1前的结果，为让后置++和前置++形成重载，给后置++多一个int类型的参数
	Date operator++(int)
	{
		Date temp(*this);
		_day += 1;
		return temp;
	}
	
	
private:
	int _year;
	int _month;
	int _day;	
};
int main()
{
	Date d1(2022, 11, 20);
	Date d2, d3;
	d2 = ++d1;
	d3 = d1++;
	return 0;
}