cpp_10.1类和对象中（十） --- 赋值运算重载符 遗留详解

最新推荐文章于 2023-09-19 15:54:24 发布
最新推荐文章于 2023-09-19 15:54:24 发布
阅读量183 收藏
点赞数
分类专栏： c++ 文章标签： c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_42536748/article/details/116855434
版权

1 日期类包含所学的四种函数

#include <iostream>
using namespace std;

#if 0
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()
	{}

	//左操作数是this指向的调用函数的对象
	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(2020, 10, 14);
	Date d2(2020, 10, 15);

	if (d1 == d2)
	{
		;
	}

	return 0;
}
#endif

如果不写==赋值运算符重载，d1 == d2 就报错。

2 注意

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

	// 注意：不能臆造运算符来进行重载
	void operator@()
	{

	}

@下面报错

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

int operator+(int left, int right)
{
	return left + right;
}

在这里插入图片描述在这里插入图片描述

上述代码中，重载操作符都是类置类型int型，并且还是无限递归，所以错误。再怎么重载也不可能重载出其他的运算符

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

#if 0
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()
	{}

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

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

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

int main()
{
	Date d1(2020, 10, 14);
	Date d2(2020, 10, 15);

	d2 = d1 + 10;
	//d1值也应该不变，注意该处的d1传过去类似于this当前对象，所以形参应该是int days
	
	int a = 10;
	int b = 20;
	int c = 0;
	c = a + b;
	//此时a，b值不变
	return 0;
}
#endif

上述该代码：看似没错，但对于+赋值操作符函数，其改变了原先的d1值。
在这里插入图片描述

其实应该是对+=进行赋值操作符函数。
修改代码：

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

再举个例子，本来是加法运算，写成减法的逻辑。
代码如下：

//此处this相当于是d1
Date operator+(/*Date* const this,*/int days)
	{
		Date temp(*this);
		temp._day -= days;
		return temp;
	}

在这里插入图片描述

实际应该是：

Date operator+(/*Date* const this,*/int days)
	{
		Date temp(*this);
		temp._day += days;
		return temp;
	}

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

#if 0
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()
	{}
	
	//类中时可以省略
	Date operator+(/*Date* const this,*/int days)
	{
		Date temp(*this);
		temp._day += days;
		return temp;
	}

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


//全局时，需要写全。
Date operator-(const Date& d, int days)
{
	Date temp(d);
	temp._day -= days;//如果_day是类中私有成员，这块不能访问，此时将其改为公有的。
	return temp;
}


int main()
{
	Date d1(2020, 10, 14);
	Date d2(2020, 10, 15);
	
	d2 = d1 - 1;
	return 0;
}
#endif

第一种：类中时可以省略，省略了Date* const this

Date operator+(/*Date* const this,*/int days)
	{
		Date temp(*this);
		temp._day += days;
		return temp;
	}

第二种：全局时，需要将参数写全。

Date operator-(const Date& d, int days)
{
	Date temp(d);
	temp._day -= days;//如果_day是类中私有成员，这块不能访问，此时将其改为公有的。
	return temp;
}

2.5 5个运算符不能重载。

.*
::
sizeof
?:
.

3 赋值运算符

#if 0
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()
	{}

	// =赋值运算符函数应注意：
	//1、返回值
	//2、参数类型
	//3、检测是否自己给自己赋值
	//4、返回*this
	//5、一个类如果没有显式定义赋值运算符重载，编译器也会生成一个，完成对象按字节序的值拷贝。
	Date& operator=(const Date& d)
	{
		// this是=运算符的左操作数，d是=运算符的右操作数
		//cout << this << "=" << &d << endl;

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

private:

	int _year;
	int _month;
	int _day;
};




int main()
{
	Date d1(2020, 10, 14);
	Date d2(2020, 10, 15);
	Date d3(2020, 10, 16);
	
	//1、d1 = d2 等价===》d1.operator=(d2)
	d1 = d2;
	d1.operator=(d2);

	//d1 = d2 = d3 等价===》d1.operator=(d2.operator=(d3));
	d1 = d2 = d3; 
	
	
	//2、自己给自己赋值没有意义，但是有时写成引用的形式，会没有看到
	d1 = d1;
	Date& d4 = d1;
	d4 = d1;


	//3、变量赋值
	//连续赋值-->其返回值是什么
	int a = 10;
	int b = 20;
	int c = 0;

	a = b;
	a = c;
	a = b = c;
	return 0;
}
#endif

3.1 参数问题：引用还是传值

void operator=(const Date d)
{
	cout << this << "=" << &d << endl;
}

int main()
{
	Date d1(2020, 10, 14);
	Date d2(2020, 10, 15);
	d1 = d2;
	return 0;
}

在这里插入图片描述

调试时，往里面走一步，发现其d1 = d2 ，调用的是拷贝构造函数。
原因：参数是按照值的方式进行传递。按照值的方式进行传递，会在传参期间生成一份拷贝。拷贝一个新的对象，这种传参效率太低了。解决这种问题，对其加引用，引用就相当于别名。d就相当于是实参的别名。

在这里插入图片描述

修改后代码如下：

void operator=(const Date& d)
{
	// this是=运算符的左操作数，d是=运算符的右操作数
	cout << this << "=" << &d << endl;
}

运行结果可以看出：将d2的地址给d1了。

在这里插入图片描述

最终结果：引用

void operator=(const Date& d)
	{
		// this是=运算符的左操作数，d是=运算符的右操作数
		//cout << this << "=" << &d << endl;
		_year = d._year;
		_month = d._month;
		_day = d._day;
	}

3.2 返回值：无返回值还是Date& 还是Date

int main()
{
	//c给b赋值，然后b给a赋值
	a = b;
	a = c;
	a = b = c;
}

在这里插入图片描述

变量可以进行连续赋值,那对象呢？

void operator=(const Date& d)
{
		// this是=运算符的左操作数，d是=运算符的右操作数
		//cout << this << "=" << &d << endl;
		_year = d._year;
		_month = d._month;
		_day = d._day;
}

int main()
{
	Date d1(2020, 10, 14);
	Date d2(2020, 10, 15);
	Date d3(2020, 10, 16);

	d1 = d2;
	d1.operator=(d2);
	d1 = d2 = d3; //  ===》d1.operator=(d2.operator=(d3));
	return 0;
}

在这里插入图片描述

不支持连续赋值。

d1 = d2;
d1.operator=(d2);

两个代码是等价的，反汇编代码如下：

在这里插入图片描述

d1 = d2 = d3; 
d1.operator=(d2.operator=(d3));

因此：返回值类型应该是个日期类型：Date，但是，应该是Date& 还是 Date

  • 一般，设计函数期间，返回值类型还是参数，涉及到自定义类型时，能先用Date&，先使用Date&.如果不用引用，有可能调用的时拷贝构造函数，在进入赋值运算符函数。

最终结果：Date&

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

3.3 返回值问题：return *this还是return d

Date& operator=(const Date& d)
{
		// this是=运算符的左操作数，d是=运算符的右操作数
		//cout << this << "=" << &d << endl;

		_year = d._year;
		_month = d._month;
		_day = d._day;
		
		return *this;
		return d;
}

int main()
{
	Date d1(2020, 10, 14);
	Date d2(2020, 10, 15);
	Date d3(2020, 10, 16);
	
	//1、d1 = d2 等价===》d1.operator=(d2)
	d1 = d2;
	d1.operator=(d2);

	//d1 = d2 = d3 等价===》d1.operator=(d2.operator=(d3));
	d1 = d2 = d3; 
	return 0;
}

不管返回是return *this还是return d，都会达到预期的效果。
在这里插入图片描述
但是，哪个效果到底更好一些呢？
针对这个语句
d1 = d2 = d3
d1.operator=(d2.operator=(d3));
d3传过去给d，d2相当于this，所以结果是返回return *this;更好。

*最终结果：return this;

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

2.4 检测是否自己给自己赋值

#if 0
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()
	{
	}
	
	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(2020, 10, 14);
	//自己给自己赋值没有意义，但是有时写成引用的形式，会没有看到
	d1 = d1;
	Date& d4 = d1;
	d4 = d1;
	return 0;
}

结论：自己给自己赋值没有意义，但是有时写成引用的形式，会没有看到，所以添加一个判断。

4 赋值运算符函数注意的点

=赋值运算符函数应注意：

  • 返回值
  • 参数类型
  • 检测是否自己给自己赋值
  • 返回*this
  • 一个类如果没有显式定义赋值运算符重载，编译器也会生成一个，完成对象按字节序的值拷贝。
Date& operator=(const Date& d)
{
	if (this != &d)
	{
		_year = d._year;
		_month = d._month;
		_day = d._day;
	}
	
	return *this;
}

在这里插入图片描述

5 ++ – 运算符函数

知识点7：++ -- 运算符重载
#if 0
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()
	{}

	// 前置++
	Date& operator++()
	{
		_day++;
		return *this;
	}

	// 后置++
	// 先使用 后加+1
	Date operator++(int)
	{
		Date temp(*this);
		_day++;
		return temp;
	}

	Date& operator--()
	{
		_day--;
		return *this;
	}

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

	int _year;
	int _month;
	int _day;
};

int main()
{
	Date d1(2020, 10, 14);
	Date d2(2020, 10, 15);
	
	//对象
	d2 = d1++;  // 后置++
	d2 = ++d1;  // 前置++

	//变量
	int a = 10;
	a++;
	a--;

	return 0;
}
#endif

5.1 前置++

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

5.2 后置++

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

5.3 前置–

Date& operator--()
{
	_day--;
	return *this;
}

5.4 后置–

Date operator--(int)
{
	Date temp(*this);
	_day--;
	return temp;
}
  • 形参部分基本都是引用：不想通过外部实参改变形参，加上const就可以。
  • 返回类型，一般先加引用，看返回实体，如果是栈上的实体，就去掉引用。

5 & 运算符函数

#if 0
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&()
	{
		cout << this << endl;
		return this;
	}

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

int main()
{
	Date d1(2020, 10, 14);
	//没有实现&赋值运算符函数时，打印地址
	cout << &d1 << endl;
	//写一个&赋值运算符函数，见到&符号，就打印地址
	&d1;


	//不打印地址，此时因为是const修饰。
	const Date d2(2020, 10, 15);
	&d2;
	return 0;
}
#endif

往期链接：
cpp_9.3类和对象中（九） — 赋值运算重载符
cpp_9.2类和对象中（八） — 拷贝构造函数
cpp_9.1 类和对象中（七）—构造函数中，无参对象如何调用？底层如何实现？
cpp_8.2类和对象中（六） — 析构函数
cpp_8.1类和对象中（五） — 构造函数链接描述
cpp_8 类和对象上（四） — this遗留
cpp_7.1 类和对象上（三） — this
cpp_7类与对象上（二） — 类对象的存储方式
cpp_6.1类与对象上（一）— 类的引入

"dandan"不能定义
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C++类的默认成员函数 —— 赋值重载
wihkum
11-27 1219
C++类的默认成员函数 —— 赋值重载
CPP运算符重载
SongyangJi
05-04 2340
文章目录函数的重载运算符重载运算符重载的作用运算符重载的方式典型运算符的重载转换构造函数类型转换函数 函数的重载 1.定义的重载函数必须具有不同的参数个数，或不同的参数类型。编译系统根据不同的参数去调用不同的重载函数，实现不同的功能。 2、仅返回值不同时，不能定义为重载函数。 运算符重载 函数重载是指完成不同功能的函数可以具有相同的函数名。 C++编译器根据函数的实参确定应该调用哪一个函数。 运算...
C语言——连续赋值的两种情况
最新发布
m0_69844675的博客
09-19 1043
我们知道变量在未声明前不能使用，所以在c=5时，c还没定义，因此语法错误。因此第二种情况，先对三个变量进行定义，再进行赋值就可以正确的进行连续赋值。因为：=具有右结合性，因此在第一种情况下等价于。第一种：int a=b=c=5;第二种：int a,b,c;那么第一种错误，第二种正确。
cpp学习笔记（1）
qq_44600017的博客
02-01 142
CPP学习笔记（1）基础沉淀——学习cpp进入cpp注释预处理与头文件预处理头文件namespace基础语法 基础沉淀——学习cpp 进入cpp 相对于以前的c来说，cpp有很多新的特点，比如输出cout funtion ‘main’ int main() { pikapika return 0; } 第一行的int main的函数头，下面是他的内容 C++要求main()的定义要从函数头开始 int是返回类型，返回给调用函数的信息 最后一句是返回指令，它用于结束该函数 注释
CPP中重载赋值操作符
qq_40467692的博客
10-06 387
在CPP中，析构函数，拷贝构造函数和赋值操作符的重载总是绑定在一起的。 一、几个问题 1、赋值操作符重载函数 参数为：const Test& obj，加上const的原因是我们不希望此函数对用来进行赋值的obj进行任何修改，其次加上const的形参，能接受const和非const的实参，反之只能接受非const的实参。 返回值为：Test&，返回值是返回被赋值着的引用，即*this，这样可以实现连续复制，类似 t2 = t1 = t3。如果...
Embarcadero 最新 Dev-Cpp 6.3版 包含TDM-GCC_9.2
09-23
Embarcadero 公司重新资助的 Dev-Cpp 6.3版，包含TDM-GCC_9.2
cpp-stub 中文使用手册
02-04
单元测试打桩开源库 cpp-stub 使用手册 中文版本，这是从git上直接下载的，git上下载的源代码在arm上调用Stub.reset方法会引发段错误，在资源cpp-stub开源代码（下载地址：...
yaml-cpp-master.zip_cpp master_opencv cmake_yaml_yaml-cpp
09-24
应用在计算机视觉方面，结合CMAKE应用，还有OPENCV。
AES.rar_AES_AES DEV_Dev-CPP
09-24
AES密码算法的程序实现，在Dev-cpp中编译通过，
Embarcadero_Dev-Cpp_6.3_TDM-GCC 9.2_Setup.exe
05-29
Dev-Cpp_6.3版本
cpp_9.3类和对象中（九） --- 赋值运算重载符
weixin_42536748的博客
05-15 241
目录1 变量之间的赋值2 引入赋值运算重载符3 如果类中涉及到资源管理时，赋值运算符重载函数必须要显式实现出来4 易出错地方 1 变量之间的赋值 int main() { int a = 10; int b = 20; a = b; return 0; } 2 引入赋值运算重载符 调用赋值运算符重载函数： 如果一个类没有显式实现赋值运算符重载函数，则编译器会生成一份默认的完成对象之间的赋值操作 int main() { Date d0; Date d1(2020, 10, 12);
C语言笔记-连续赋值
热门推荐
RedTea_的博客
10-26 1万+
C语言中连续赋值问题 C语言中可以进行连续赋值,如a=b=c=1,“=”运算符是从右至左结合,意味着先将1赋给c,再将c赋给b,再将b赋给a,此时 a,b,c都是1,即完成了连续赋值。但是定义时连续赋值违反了C语言中先定义后使用原则,即定义时连续赋值编译器会报错。 错误写法：定义时连续赋值 #include<stdio.h> int main() { int a=b=c=1; printf("%d,%d,%d\n",a,b,c); return 0; } 正确写法 #include<
c/c++连续赋值
RYSX002的博客
04-09 1256
#include <stdio.h> #include <math.h> #include <stdlib.h> int main(void) { int a=10, b=20, c=30, d = 4; printf("%d\t%d\t%d\t%d\n", a, b, c, d); printf("a -= b += c *= d\n"); a -= b += c *= d; printf("%d\t%d\t%d\t%d\n.
C++类对象的复制与赋值
qq_20853741的博客
02-20 5786
本文主要介绍C++中类对象的赋值操作、复制操作，以及两者之间的区别，另外还会讲到“深拷贝”与“浅拷贝”的相关内容。 本系列内容会分为三篇文章进行讲解。 1 对象的赋值 1.1 what 如同基本类型的赋值语句一样，同一个类的对象之间也是可以进行赋值操作的，即将一个对象的值赋给另一个对象。 对于类对象的赋值，只会对类中的数据成员进行赋值，而不对成员函数赋值。 例如：obj1 和 obj2 是同一类 ClassA 的两个对象，那么对象赋值语句“obj2 = obj1;” 就会把对象 obj1 的数据
cpp——类——赋值操作符函数
mardax的专栏
02-13 1324
概述 赋值操作符函数模仿内置类型的赋值操作 赋值操作符函数只是赋值操作符重载的一个特殊版本，其形参列表为[const] classname &，当实例对象赋值操作时调用 辅助类 class CAnimal { public: CAnimal() : mGroup(0) { cout << "CAnimal()" << endl; } CAnimal(int group) : mGroup(group) { cout <<
C++中的对象的赋值和复制
weixin_33739523的博客
09-07 422
对象的赋值 如果对一个类定义了两个或多个对象，则这些同类的对象之间可以互相赋值，或者说，一个对象的值可以赋给另一个同类的对象。这里所指的对象的值是指对象中所有数据成员的值。 对象之间的赋值也是通过赋值运算符“=”进行的。本来赋值运算符“=”只能用来对单个的变量赋值，现在被扩展为两个同类对象之间的赋值，这是通过对赋值运算符的重载实现的。 实际上这个过程是通过成员复制来实现的，即将一个对...
cppTest-7.4：对象赋值与重载赋值运算符=
炜X影的专栏
12-29 754
/** *cppTest-7.4：对象赋值与重载赋值运算符= * *需要说明的是，关于赋值运算符重载的函数定义并不是必须的。 *此外，在C++中，程序员不能定义新的运算符，被重载的运算符保持原有的优先级和结合性，而不论运算符重载函数内代码是什么样的形式。 *对于赋值操作，必须返回表达式的值，也即等式右边的值，只有这样，才能使连续赋值如c=b=a合法。程序中是通过返回由this指向的对象来
C++类的赋值运算符“=”重载，以及深拷贝和浅拷贝
《好好先生》专栏
11-23 7976
C++类的赋值运算符“=”重载，以及深拷贝和浅拷贝 在面向对象程序设计中，对象间的相互拷贝和赋值是经常进行的操作。 如果对象在申明的同时马上进行初始化操作，则称之为拷贝运算。例如： class1 A("af"); class1 B=A; 此时，其实际调用的是B(A)这样的浅拷贝操作。 如果对象在申明之后，再进行赋值运算，称之为赋值运算。例如： class1 A("af"); class
C++ 关系运算符重载与赋值运算符重载
cpp_learner的博客
02-08 1535
在我之前的文章中，介绍了算术运算符重载的基本使用，现在我将继续介绍关系运算符重载和赋值运算符重载。 还没看过的朋友可以点击链接前去看一下：C++ 运算符重载 https://blog.csdn.net/cpp_learner/article/details/104208689 其实他们之间的用法都是类似的，没有什么区别，都是围绕着关键字“operator"展开。 下面我举了两例子来介绍关系运算符重...
embarrcadero_dev-cpp_6.3tdm-gcc 9.2_setup
09-09
embarrcadero_dev-cpp_6.3tdm-gcc 9.2_setup是一个与编程语言C++相关的开发工具，它结合了Embarcadero公司的开发环境和TDM-GCC编译器版本9.2。 Embarcadero开发环境是一套功能强大的集成开发环境（IDE），用于开发...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值