C++类（赋值运算符重载）

最新推荐文章于 2025-03-21 22:14:16 发布

原创最新推荐文章于 2025-03-21 22:14:16 发布 · 677 阅读

7 ·

本内容遵循CC 4.0 BY-SA版权协议

标签

#c++ #开发语言

C++ 专栏收录该内容

40 篇文章

订阅专栏

一、运算符重载

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

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

bool operator==(const Date& a, const Date& b)//函数原型

注：

该关键字不能通过连接其他C++中不存在的符号创建新的操作符：如operator@
重载操作符必须有一个自定义类型参数
用于内置类型（int、char、double等）的运算符，其含义不能改变。因此operator只能用于自定义类型
作为类成员函数重载时，其形参看起来会比操作数数目少1，因为成员函数的第一个参数为隐藏的this指针
“.* :: sizeof ?: .”以上5个运算符不能重载

当运算符重载在自定义类外面写时，代码如下：

class Date
{
public:
	Date(const int& year = 1, const int& month = 1, const int& day = 1)
	{
		_year = year;
		_month = month;
		_day = day;
	}
//private: //不屏蔽private，类外面无法调用以下三个变量
	int _year;
	int _month;
	int _day;
};
bool operator==(const Date& a, const Date& b)
{
	return a._day == b._day
		&& a._month == b._month
		&& a._year == b._year;
}
int main()
{
	Date d(2024, 2, 4);
	Date d1(2024, 11, 29);
	cout << (d == d1) << endl;
	return 0;
}

当运算符重载在自定义类里面写时，代码如下：

class Date
{
public:
	Date(const int& year = 1, const int& month = 1, const int& day = 1)
	{
		_year = year;
		_month = month;
		_day = day;
	}
    //bool operator==(Date* this, const Date& a)
    //这里的this指针指向的是左操作数，即==左边的数
    //this指针是编译器自动生成的并传递，不需要自己定义
    //this指针只能在类内部成员函数内使用，不能显示定义
	bool operator==(const Date& a)
	{
		//return this->_day == a._day
		//	&& this->_month == a._month
		//	&& this->_year == a._year;
		return _day == a._day
			&& _month == a._month
			&& _year == a._year;
	}
private:
	int _year;
	int _month;
	int _day;
};

int main()
{
	Date d(2024, 2, 4);
	Date d1(2024, 11, 29);
	cout << (d == d1) << endl;
	return 0;
}

二、赋值运算符重载

1.赋值运算符重载格式

参数类型：const T&,传递时用引用可以提高传参效率（T是类类型）
返回值类型：T&，返回引用可以提高返回的效率，有返回值的目的是为了连续赋值
检测是否自己给自己赋值
返回*this：要符合连续赋值的含义

class Date
{
public:
	Date(const int& year = 1, const int& month = 1, const int& day = 1)
	{
		_year = year;
		_month = month;
		_day = day;
	}
	Date(const Date& a) //拷贝构造函数
	{
		_year = a._year;
		_month = a._month;
		_day = a._day;
	}
	Date& operator=(const Date& a)//使用Date作为返回值而不用void，是为了连续赋值
	{                             //如a = b = c，如果用void则无法连续赋值    
        if(this != &a)            //避免自己给自己赋值
        {		                  
            _year = a._year;
		    _month = a._month;
		    _day = a._day;
        }        
		return *this;//由于*this出了作用域不会销毁，因此可以用引用返回提高效率
	}
private:
	int _year;
	int _month;
	int _day;
};

int main()
{
	Date d(2024, 2, 4);
	Date d1 = d;//这里调用拷贝构造函数
                //含义：一个对象已经存在，另一个对象不存在
                //用已经存在的对象去初始化不存在的对象
	Date d2;
	d2 = d;//这里调用赋值运算符重载，含义：两个对象都存在，将一个对象的值赋值给另一个对象
	return 0;
}

运行结果：

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

class Date
{
public:
	Date(const int& year = 1, const int& month = 1, const int& day = 1)
	{
		_year = year;
		_month = month;
		_day = day;
	}
	Date(const Date& a)
	{
		_year = a._year;
		_month = a._month;
		_day = a._day;
	}

//private:
	int _year;
	int _month;
	int _day;
};
Date& operator=(const Date& a,const Date& b)
{
	if (&a != &b)
	{
		a._year = b._year;
		a._month = b._month;
		a._day = b._day;
	}
	return a;
}

int main()
{
	Date d(2024, 2, 4);
	Date d1 = d;

	Date d2;
	d2 = d;
	return 0;
}

代码运行报错：