03C++类与对象之运算符重载

最新推荐文章于 2024-06-13 17:39:47 发布
最新推荐文章于 2024-06-13 17:39:47 发布
阅读量357 收藏 2
点赞数 2
分类专栏： c++ 文章标签： c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Ruiren_/article/details/130735517
版权

文章目录

在这里插入图片描述

C++类与对象之运算符重载与const成员

运算符重载

赋值运算符重载

运算符重载

C++为了增强代码的可读性引入了运算符重载，运算符重载是具有特殊函数名的函数，也具有其
返回值类型，函数名字以及参数列表，其返回值类型与参数列表与普通的函数类似。
函数名字为：关键字operator后面接需要重载的运算符符号。
函数原型：返回值类型 operator操作符(参数列表)
注意：
不能通过连接其他符号来创建新的操作符：比如operator@
重载操作符必须有一个类类型参数
用于内置类型的运算符，其含义不能改变，例如：内置的整型+，不 能改变其含义
作为类成员函数重载时，其形参看起来比操作数数目少1，因为成员函数的第一个参数为隐
藏的this
. :: sizeof ?: . 注意以上5个运算符不能重载。这个经常在笔试选择题中出现*

日期类的实现与运算符重载

像这种运算符重载，我们可以思考多个运算符代码到复用(在这里统一说一下const可以暂时不管，同时此处会涉及到后面的友元类，友元类就是虽然不是成员函数，就是没用this指针，但是可以访问私有成员数据)

基本实现

class Date
{
	friend ostream& operator<<(ostream& out, const Date& d);

	friend istream& operator>>(istream& in, Date& d);
private:
	int _year;
	int _month;
	int _day;

public:
    Date(){}
	Date(int year, int month, int day);

	int  Get_day()
	{
		return _day;
	}
    
	int Get_month()
	{
		return _month;
	}
    
	int Get_year()
	{
		return _year;
	}
    
	void Print()
	{
		cout << _year << "-" << _month << "-" << _day << endl;
	}
    
	int Getmonthday(int year,int month)
	{
		static int monthday[13]={0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30,31};
		if (month == 2 && ((year % 4 == 0 && year % 100 != 0) || (year % 400 == 0)))
		{
			return 29;
		}
		else
		{
			return monthday[month];
		}
	}
	
	Date(const Date& B)
	{
		
		_day = B._day;
		_month = B._month;
		_year = B._year;
	}
    
    bool operator<(const Date& x) const;
	bool operator==(const Date& x) const;
	bool operator<=(const Date& x) const;
	bool operator>(const Date& x) const;
	bool operator>=(const Date& x) const;
	bool operator!=(const Date& x) const;
	Date& operator+=(int day);
	Date operator+(int day) const;

	Date& operator-=(int day);
	Date operator-(int day) const;
	int operator-(const Date& d) const;
	Date& operator=(const Date& d)  
	{
		if (!(this == &d))
		{
			_year = d._year;
			_month = d._month;
			_day = d._day;
		}
		return *this;
	}
    Date operator++(int)
	{
		Date temp(*this);
		_day += 1;
		return temp;
	}

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

赋值运算符重载

  • 参数类型：const T&，传递引用可以提高传参效率(因为无需调用赋值构造函数)

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

    	Date A(2023,5,4);
	Date B(A);//赋值构造
	Date C;
	Date D;
	C = D = B;//B赋值给D，同时D的赋值函数返回D的引用，将D赋给C

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

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

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

比较类运算符的重载

  • 参数类型：const T&，传递引用可以提高传参效率
  • 返回值类型：T&，返回引用可以提高返回的效率，有返回值目的是为了支持连续赋值
  • 代码复用：可以先重载<和==，其他的复用其代码就行
  • 返回bool：即判断是否正确
bool Date::operator<(const Date& x) const
{
	if (_year < x._year)
	{
		return true;
	}
	else if (_year == x._year && _month < x._month)
	{
		return true;
	}
	else if (_year == x._year && _month == x._month && _day < x._day)
	{
		return true;
	}

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

bool Date::operator<=(const Date& x) const
{
	return *this < x || *this == x;
}

bool Date::operator>(const Date& x) const
{
	return !(*this <= x);
}

bool Date::operator>=(const Date& x) const
{
	return !(*this < x);
}

bool Date::operator!=(const Date& x) const
{
	return !(*this == x);
}

二元运算符±的重载

Date& Date::operator+=(int day)
{
	if (day < 0)
	{
		return *this -= -day;
	}

	_day += day;
	while (_day > Getmonthday(_year, _month))
	{
		_day -= Getmonthday(_year, _month);
		++_month;
		if (_month == 13)
		{
			++_year;
			_month = 1;
		}
	}

	return *this;
}

Date Date::operator+(int day)  const
{
	Date tmp(*this);
	tmp += day;
	return tmp;
}

Date& Date::operator-=(int day)
{
	if (day < 0)
	{
		return *this += -day;
	}

	_day -= day;
	while (_day <= 0)
	{
		--_month;
		if (_month == 0)
		{
			_month = 12;
			--_year;
		}

		_day += Getmonthday(_year, _month);
	}

	return *this;
}

Date Date::operator-(int day) const//日期加天数，算多少天前的日期
{
	Date tmp = *this;
	tmp -= day;
	return tmp;
}

int Date::operator-(const Date& d) const//日期减日期，算相差的天数
{
	Date max = *this;
	Date min = d;
	int flag = 1;

	if (*this < d)
	{
		max = d;
		min = *this;
		flag = -1;
	}

	int n = 0;
	while (min != max)
	{
		++min;
		++n;
	}

	return n * flag;
}

前置++和后置++重载

前置++和后置++都是一元运算符，为了让前置++与后置++形成能正确重载
C++规定：后置++重载时多增加一个int类型的参数，但调用函数时该参数不用传递，编译器
自动传递
注意：后置++是先使用后+1，因此需要返回+1之前的旧值，故需在实现时需要先将this保存
一份，然后给this+1

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

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

同理，前置–和后置–

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

总体实现代码

#include"date.h"

Date::Date(int year, int month, int day)
{
	if (month > 0 && month < 13
		&& day > 0 && day <= Getmonthday(year, month))
	{
		_year = year;
		_month = month;
		_day = day;
	}
	else
	{
		cout << "非法日期" << endl;
		assert(false);
	}
}

bool Date::operator<(const Date& x) const
{
	if (_year < x._year)
	{
		return true;
	}
	else if (_year == x._year && _month < x._month)
	{
		return true;
	}
	else if (_year == x._year && _month == x._month && _day < x._day)
	{
		return true;
	}

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

bool Date::operator<=(const Date& x) const
{
	return *this < x || *this == x;
}

bool Date::operator>(const Date& x) const
{
	return !(*this <= x);
}

bool Date::operator>=(const Date& x) const
{
	return !(*this < x);
}

bool Date::operator!=(const Date& x) const
{
	return !(*this == x);
}

Date& Date::operator+=(int day)
{
	if (day < 0)
	{
		return *this -= -day;
	}

	_day += day;
	while (_day > Getmonthday(_year, _month))
	{
		_day -= Getmonthday(_year, _month);
		++_month;
		if (_month == 13)
		{
			++_year;
			_month = 1;
		}
	}

	return *this;
}

Date Date::operator+(int day)  const
{
	Date tmp(*this);
	tmp += day;
	return tmp;
}

Date& Date::operator-=(int day)
{
	if (day < 0)
	{
		return *this += -day;
	}

	_day -= day;
	while (_day <= 0)
	{
		--_month;
		if (_month == 0)
		{
			_month = 12;
			--_year;
		}

		_day += Getmonthday(_year, _month);
	}

	return *this;
}

Date Date::operator-(int day) const
{
	Date tmp = *this;
	tmp -= day;
	return tmp;
}

int Date::operator-(const Date& d) const
{
	Date max = *this;
	Date min = d;
	int flag = 1;

	if (*this < d)
	{
		max = d;
		min = *this;
		flag = -1;
	}

	int n = 0;
	while (min != max)
	{
		++min;
		++n;
	}

	return n * flag;
}

ostream& operator<<(ostream& out,const Date& d)
{
	out << d._year << "年" << d._month << "月" << d._day << "日" << endl;
	return out;
}
istream& operator>>(istream& in,Date& d)
{
	int year, month, day;
	in >> year >> month >> day;

	if (month > 0 && month < 13
		&& day > 0 && day <= d.Getmonthday(year, month))
	{
		d._year = year;
		d._month = month;
		d._day = day;
	}
	else
	{
		cout << "非法日期" << endl;
		assert(false);
	}
	return in;
}

const成员

const的好处

1.防止程序员犯错

就拿上面的日期减天数的代码来说

这个代码不能改变原来的日期类，只有-=才改变。如果你没有加const，你可能在写代码时犯错，不小心把原来的日期类改了

Date Date::operator-(int day) const
{
	Date tmp = *this;
	tmp -= day;
	return tmp;
}
2.提高代码的复用性

如果-的重载没有加const

Date Date::operator-(int day) 
{
	Date tmp = *this;
	tmp -= day;
	return tmp;
}

我们运行这个代码

const Date d1(2023,5,1);
	Date d2 = d1 - 100;3

在这里插入图片描述

原因在于d1是 const Date类，不能改变，所以他的取地址应该是const Data*this，而系统传过去的this指针是一个普通的，这属于权限放大了（具体可以看看我前面的&（引号）的使用），而又因为this不能自己改C++添加了个在函数后面的const 的方法给this指针添加const

那么我们的const的对象就可以调用-这个函数了

const 成员与函数重载规则

能不能构成重载得看是单纯传值还是是否涉及到权限问题，比如形参是const 引用和指针，这就涉及到了权限所以能重载，而类的成员函数有this指针，也能构成，如果是传值的话，没有涉及到权限所以不构成，但以下图片中的text函数未构成函数重载的原因是const 为管控到this指针，所以未涉及到权限问题，未构成函数重载（记住只是单纯的赋值重载不行，其他都可以）

再者调用关系上，如果两个函数都实现了，那么const 类型的调const的，普通的调普通的，但如果只有const函数，那么普通的类型也可以调const类型的函数

Ruiren.
关注
  • 2
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 2
    评论
专栏目录
C++实践分数类中运算符重载的方法参考
01-21
【项目-分数类中的运算符重载】 （1）实现分数类中的运算符重载，在分数类中可以完成分数的加减乘除（运算后再化简）、比较（6种关系）的运算。 class CFraction { private: int nume; // 分子 int deno; // ...
C++ 上课/复习ppt运算符重载.pptx
09-30
C++ 上课/复习ppt运算符重载.pptx
P121~126C++类和对象C++运算符重载学习笔记.docx
04-13
P121~126C++类和对象C++运算符重载学习笔记.docx
c++本科作业 矩阵运算 运算符重载
04-09
For this task, put your code in the following files: Matrix.cpp, Matrix.h. You are to write a class Matrix which includes appropriate fields associated with 2*2 matrices. A 2*2 matrix takes the ...
C++课程作业：类定义、运算符重载、类模板
06-09
C++课程作业：类定义、运算符重载、类模板
【C++】——Stack与Queue（含优先队列（详细解读）
m0_74092462的博客
06-09 967
优先队列是一种容器适配器，根据严格的弱排序标准，它的第一个元素总是它所包含的元素中最大的。stack是一种容器适配器，专门用在具有后进先出操作的上下文环境中，其删除只能从容器的一端进行元素的插入与提取操作。 队列是一种容器适配器，专门用于在FIFO上下文(先进先出)中操作，其中从容器一端插入元素，另一端提取元素。
C++——计算不同的非空子串个数
我发布的博客，快来抄答案吧
06-09 128
BCSP-X 11题 C++代码详解
【C语言从入门到入土】第六章 指针(下)
v13111329954的博客
06-08 665
本文主要介绍了指针偏移，通过指针引用数组，指针数组，数组指针，函数指针，指针函数，二级指针
LeetCode 算法：轮转数组c++
小金牛来了
06-09 643
LeetCode 算法：轮转数组c++
【C++】list 容器的增删改查---模拟实现（图例超详细解析！！！）
weixin_45031801的博客
06-12 847
STL 中的 list 是一个带头双向循环链表，作为链表的终极形态，各项操作性能都很优秀，尤其是 list 中迭代器的设计更是让人拍案叫绝，如此优秀的容器究竟是如何实现的呢？本文将会带大家一起从0~1 去模拟实现STL库中的 list 容器，以便于让大家更好的巩固之前学习过的 缺省参数、封装、类的6大默认函数等。
C++|哈希结构封装unordered_set和unordered_map
weixin_68201503的博客
06-11 675
上一篇章，学习了unordered系列容器的使用，以及哈希结构，那么这一篇章将通过哈希结构来封装unordered系列容器，来进一步的学习他们的使用以及理解为何是如此使用。其实，哈希表的封装方式和红黑树的封装方式形式上是差不多的，如果有了红黑树的封装理解经验，我相信在理解哈希封装的过程会减少负担的。当然，在使用哈希结构中采用的是更具代表的哈希桶，接下来进行封装。
Python 调用 C 和 C 调用 Python 方法
Ephemeroptera的博客
06-10 516
python/c 的相互调用
【C语言】一维数组（详解）
lrq13965748542的博客
06-11 963
有了下标引用操作符，我们可以轻松访问到数组中的元素了，比如我们访问下标为7的元素，我们就可以使用 arr[7]，想要访问下标为3的元素，就使用 arr[3]。我们知道数组中所有元素的类型都是相同的，那只要计算出一个元素所占字节的个数，数组的元素个数就能计算出来。以后在代码中需要数组元素个数的地方就不用固定写死了，使用上面的计算，不管数组怎样变化，计算出的大小也就随着变化了。数组也是有类型的，数组算是一种自定义类型，去掉数组名留下的就是数组的类型。实现了数组的访问，现在我们也可以实现对数组中进行数据的输入。
c++ 智能指针使用注意事项及解决方案
最新发布
Clarence的博客
06-13 335
对智能指针的总结
手搓顺序表（C语言）
m0_62646213的博客
06-12 1091
顺序表头插头删，尾插尾删，任意位置插入删除的实现和优劣分析
笔记97：C++ 中 string / char 和 int 之间相互转化
weixin_44063383的博客
06-12 189
方法：使用强制类型转化进行 char 和 int 之间的转换；
CRC8校验算法源码——C语言版
Miao8miao的博客
06-12 222
本文以CRC8实际代码为例启发各位读者，如何编写一个CRC的校验算法。让各位读者直接跳过繁琐的原理说明阶段，快速应用到工程当中
深度搜索算法3（c++）
mmz1207的博客
06-08 370
农夫约翰总是想要一个农场的地图，所以他拍摄了一张N行M列的卫星照片。一部分的照片看起来像这样： 他认为每个联通块都是一个谷仓或一头奶牛。农夫约翰认为一个联通块是谷仓，当且仅当它是一个完整的矩形，否则该联通块是一头奶牛。在下面的照片中，有三个谷仓（大小分别为2x1,2x5和1x1）和两头奶牛。计算他的卫星照片中谷仓和奶牛的数量。行2..N + 1：行i + 1表示照片的行i包含M个字 符（且不含空格）。行1：两个空格分隔的整数：N和M。行1：照片中的谷仓数量。行2：照片中的奶牛数量。
基于python-CNN深度学习的食物识别-含数据集+pyqt界面
分享知识
06-10 328
本代码对数据集进行了预处理，包括通过在较短边增加灰边，使得图片变为正方形(如果图片原本就是正方形则不会增加灰边)，和旋转角度，来扩增增强数据集，运行02深度学习模型训练.py就会将txt文本中记录的训练集和验证集进行读取训练，训练好后会保存模型在本地。运行03pyqt_ui界面.py就可以有个可视化的ui界面，通过点击按钮可以加载自己感兴趣的图片识别。下载本代码后，有个requirement.txt文本，里面介绍了如何安装环境，环境需要自行配置。本代码是基于python pytorch环境安装的。
c++类的赋值运算符重载
09-10
c类的赋值运算符重载是一种特殊的函数，它具有特殊的函数名、返回值类型和参数列表。为了增强代码的可读性，C语言引入了运算符重载。赋值运算符重载函数除了可以有对象引用这样的参数之外，还可以有其他参数，但是这些参数必须给出默认值。例如，一个赋值运算符重载函数的原型可以是People& operator=(const People& peo, int a = 100)。这样，在使用赋值运算符时，如果没有提供额外的参数，就会使用默认值。 在C语言中，赋值运算符重载的函数名为"operator="，它后面接着需要重载的赋值运算符符号。函数的返回值类型和参数列表与普通函数类似。例如，赋值运算符重载的函数原型可以是：People& operator=(const People& peo)。 通过重载赋值运算符，我们可以解决一些问题。例如，当一个类的成员变量是指针类型时，使用默认的赋值运算符只会复制指针的值，导致两个对象的指针指向同一块内存空间。为了满足实际需求，我们可以重载赋值运算符，使其完成指针的深拷贝。这样，在赋值时会创建一个新的内存空间，并将源对象的值复制到新的内存空间中。<span class="em">1</span><span class="em">2</span><span class="em">3</span>

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

Ruiren.

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值