黑马程序员C++类和对象【5】 —— 运算符重载（蓝桥杯必备知识）万字超详解

news2025/7/18 9:45:09

目录

🤡加号运算符重载

🤡左移运算符重载

🤡递增运算符重载

🤡递减运算符重载

🤡赋值运算符重载

🤡关系运算符重载

🤡函数调用运算符重载（仿函数）

🤡加号运算符重载

如果现在我们希望对对象的属性进行求和，我们可能会想到用+直接进行相加，那么就让我们先来试试吧，下面是我实例化两个对象的两个属性相加，结果编译器会报错，说我的操作数和运算符不匹配，那么这时候就需要自己手动重载运算符了。

作用：实现两个自定义数据类型相加的运算

使用运算符重载（注意：重载函数名必须是编译器提供的operator+）

成员函数重载

//运算符重载
class Person {
public:

	//1、成员函数重载+号
	Person operator+(Person& p)
	{
		Person temp;
        //this指针指向的是调用该成员函数的对象（p1），这里面的p是指传进来的p2的引用
		temp.m_A = this->m_A + p.m_A;
		temp.m_B = this->m_B + p.m_B;
		return temp;
	}


	int m_A;
	int m_B;

};
void test01()
{
	Person p1;
	p1.m_A = 10;
	p1.m_B = 10;
	Person p2;
	p2.m_A = 10;
	p2.m_B = 10;

	Person p3 = p1 + p2;    //等价于 p1.operator+(p2)
	cout << p3.m_A << " " << p3.m_B << endl;
}

int main() {
	test01();    //调用

	system("pause");
	return 0;
}

全局函数重载

//运算符重载
class Person {
public:

	//1、成员函数重载+号
	//Person operator+(Person& p)
	//{
	//	Person temp;
	//	temp.m_A = this->m_A + p.m_A;
	//	temp.m_B = this->m_B + p.m_B;
	//	return temp;
	//}

	int m_A;
	int m_B;

};

//2、全局函数重载  + 号
Person operator+(Person &p1,Person &p2)
{
	Person temp;
	temp.m_A = p1.m_A + p2.m_B;
	temp.m_B = p1.m_B + p2.m_B;
	return temp;
}

void test01()
{
	Person p1;
	p1.m_A = 10;
	p1.m_B = 10;
	Person p2;
	p2.m_A = 10;
	p2.m_B = 10;

	//Person p3 = p1 + p2;		//成员函数重载本质调用等价于 p1.operator+(p2)
	Person p3 = p1 + p2;			//全局函数重载本质调用等价于 operator+(p1,p2)
	cout << p3.m_A << " " << p3.m_B << endl;
}

int main() {
	test01();

	system("pause");
	return 0;
}

运算符重载也可以发生函数重载

class Person {
public:
	Person() {};
	Person(int a, int b)
	{
		this->m_A = a;
		this->m_B = b;
	}
	//成员函数实现 + 号运算符重载
	Person operator+(const Person& p) {
		Person temp;
		temp.m_A = this->m_A + p.m_A;
		temp.m_B = this->m_B + p.m_B;
		return temp;
	}


public:
	int m_A;
	int m_B;
};

//全局函数实现 + 号运算符重载
//Person operator+(const Person& p1, const Person& p2) {
//	Person temp(0, 0);
//	temp.m_A = p1.m_A + p2.m_A;
//	temp.m_B = p1.m_B + p2.m_B;
//	return temp;
//}

//运算符重载 可以发生函数重载 
Person operator+(const Person& p2, int val)
{
	Person temp;
	temp.m_A = p2.m_A + val;
	temp.m_B = p2.m_B + val;
	return temp;
}

void test() {

	Person p1(10, 10);
	Person p2(20, 20);

	//成员函数方式
	Person p3 = p2 + p1;  //相当于 p2.operaor+(p1)
	cout << "mA:" << p3.m_A << " mB:" << p3.m_B << endl;


	Person p4 = p3 + 10; //相当于 operator+(p3,10)
	cout << "mA:" << p4.m_A << " mB:" << p4.m_B << endl;

}

int main() {

	test();

	system("pause");

	return 0;
}

 总结1：对于内置的数据类型的表达式的的运算符是不可能改变的；

总结2：不要滥用运算符重载

🤡左移运算符重载

比如这个例子，显然下面这个不能输出的。

左移运算符重载的作用：可以输出自定义数据类型

可以转到定义查看cout是ostream类型的 

//左移运算符重载

class Person {
	friend ostream& operator<<(ostream& out, Person& p);

public:

	Person(int a, int b)
	{
		this->m_A = a;
		this->m_B = b;
	}

	//成员函数 实现不了（  p << cout 不是我们想要的效果 )
	//void operator<<(Person& p){
	//}
	 
private:
	int m_A;
	int m_B;
};

//全局函数实现左移重载
//ostream对象只能有一个
ostream& operator<<(ostream& out, Person& p) {
    //内部就是一个简单的对象属性的输出
	out << "a:" << p.m_A << " b:" << p.m_B << endl;;
	return out;
}

void test() {

	Person p1(10, 20);

	//如果返回的是void型，后面就不能追加输出了
	cout << p1 << "hello world" << endl; //链式编程
}

int main() {

	test();

	system("pause");

	return 0;
}

 总结：重载左移运算符配合友元可以实现输出自定义数据类型

🤡递增运算符重载

作用： 通过重载递增运算符，实现自己的整型数据


class MyInteger {

	friend ostream& operator<<(ostream& out, MyInteger myint);

public:
	MyInteger() {
		m_Num = 0;
	}
	//前置++
	MyInteger& operator++() {
		//先++
		m_Num++;
		//再返回
		return *this;
	}

	//后置++
	MyInteger operator++(int) {
		//先返回
		MyInteger temp = *this; //记录当前本身的值，然后让本身的值加1，但是返回的是以前的值，达到先返回后++；
		m_Num++;
		return temp;
	}

private:
	int m_Num;
};


ostream& operator<<(ostream& out, MyInteger myint) {
	out << myint.m_Num;
	return out;
}


//前置++ 先++ 再返回
void test01() {
	MyInteger myInt;
	cout << ++myInt << endl;
	cout << myInt << endl;
}

//后置++ 先返回 再++
void test02() {

	MyInteger myInt;
	cout << myInt++ << endl;
	cout << myInt << endl;
}

int main() {

	test01();
	//test02();

	system("pause");

	return 0;
}

 总结： 前置递增返回引用，后置递增返回值

🤡递减运算符重载

class MyInteger {
	//友元函数，是函数可以调用类里面的私有属性
	friend ostream& operator<<(ostream& out, MyInteger myint);
public:
		MyInteger() {
			//给m_Num赋初值。
			m_Num = 2;
		}
		
		//前置--
		MyInteger& operator--() {
			//先 -- 
			--m_Num;
			//再返回
			return *this;
		}
		
		//后置--
		MyInteger operator--(int) {
			//先返回
			MyInteger temp = *this; //记录当前本身的值，然后让本身的减1，但是返回的是以前的值，达到先返回后--；
			m_Num--;
			return temp;
		}
private:
	int m_Num;
};

//全局函数重载左移运算符用于输出
ostream& operator<<(ostream& out, MyInteger myint) {
	out << myint.m_Num;
	return out;
}

//前置-- 先-- 再返回
void test01() {
	MyInteger myInt;
	cout <<--myInt << endl;
	cout << myInt << endl;
}

//后置-- 先返回 再--
void test02() {

	MyInteger myInt;
	cout << myInt-- << endl;
	cout << myInt << endl;
}

int main() {
	test01();
	test02();
	
	system("pause");
	return 0;  
}

 递减和递增一样，前置返回引用，后置返回值。

🤡赋值运算符重载

 

C++编译器至少给一个类添加4个函数

  1. 默认构造函数(无参，函数体为空)

  2. 默认析构函数(无参，函数体为空)

  3. 默认拷贝构造函数，对属性进行值拷贝

  4. 赋值运算符 operator=, 对属性进行值拷贝

 

class Person
{
public:
	Person(int age) {
		m_Age = new int(age);
	}

	~Person() {
		if (m_Age != NULL) {
			delete m_Age;
			m_Age = NULL;
		}
	}
	int *m_Age;
};

void test01()
{
	Person p1(18);
	cout << "p1的年龄为：" << *p1.m_Age << endl;

	Person p2(28);
	p2 = p1;
	cout << "p1的年龄为：" << *p2.m_Age << endl;
}

int main() {
	test01();

	system("pause");
	return 0;
}

写了个析构函数，释放了自己手动在堆上面申请的内存 ，结果出现崩溃了。。。

 这里实际上是浅拷贝的问题。

 p1和p2公用一块堆内存18，并没有再重新开辟和p1的属性值一样的空间给p2，他们都指向这一块内存。

 在函数执行完之后，p2被释放了，再判断p2空间是否为空，不为空释放一次，p1进行同样操作。

堆区内存重复释放，重新崩溃！

解决方案：利用深拷贝，解决浅拷贝带来的问题。

 

	//重载赋值运算符
	void operator=(Person& p)
	{
		//编译器是提供浅拷贝
		//m_Age = p.m_Age;

		//应该先判断编译器是否有属性在堆区，如果有先释放干净，然后再深拷贝
		if (m_Age != NULL) {
			delete m_Age;
			m_Age = NULL;
		}

		//深拷贝
		m_Age = new int(*p.m_Age);

 直接在类里面添加上面代码就可以实现了

但是，你以为这就完了吗

如果这时候要求连续赋值操作，p3 = p2 = p1；则会报错，为啥呢？

仔细看，你前面返回的是void类型，这里需要返回对象本体Person&。

重载部分代码：

	//重载赋值运算符
	Person& operator=(Person& p)
	{
		//编译器是提供浅拷贝
		//m_Age = p.m_Age;

		//应该先判断编译器是否有属性在堆区，如果有先释放干净，然后再深拷贝
		if (m_Age != NULL) {
			delete m_Age;
			m_Age = NULL;
		}

		//深拷贝
		m_Age = new int(*p.m_Age);

		//返回对象本身
		return *this;
	}

 总结：

        先在堆区开辟内存

重载流程：

  1.         判断是否有内存，进行清空操作。
  2.         进行深拷贝
  3.         返回自身

🤡关系运算符重载

作用：重载关系运算符，可以让两个自定义类型对象进行对比操作

class Person
{
public:
	Person(string name, int age)
	{
		this->m_Name = name;
		this->m_Age = age;
	};

    //==的重载
	bool operator==(Person & p)
	{
		if (this->m_Name == p.m_Name && this->m_Age == p.m_Age)
		{
			return true;
		}
		else
		{
			return false;
		}
	}

    //!=的重载
	bool operator!=(Person & p)
	{
		if (this->m_Name == p.m_Name && this->m_Age == p.m_Age)
		{
			return false;
		}
		else
		{
			return true;
		}
	}


	string m_Name;
	int m_Age;
};

void test01()
{
	//int a = 0;
	//int b = 0;

	Person a("孙悟空", 18);
	Person b("孙悟空", 18);

	if (a == b)
	{
		cout << "a和b相等" << endl;
	}
	else
	{
		cout << "a和b不相等" << endl;
	}

	if (a != b)
	{
		cout << "a和b不相等" << endl;
	}
	else
	{
		cout << "a和b相等" << endl;
	}
}


int main() {

	test01();

	system("pause");

	return 0;
}

🤡函数调用运算符重载（仿函数）

  • 函数调用运算符 () 也可以重载

  • 由于重载后使用的方式非常像函数的调用，因此称为仿函数

  • 仿函数没有固定写法，非常灵活

class MyPrint
{
public:
	void operator()(string text)
	{
		cout << text << endl;
	}

};
void test01()
{
	//重载的（）操作符 因为调用的时候和函数调用很像，所以也称为仿函数
	MyPrint myFunc;
	myFunc("hello world");
}


class MyAdd
{
public:
	int operator()(int v1, int v2)
	{
		return v1 + v2;
	}
};

void test02()
{
	MyAdd add;
	int ret = add(10, 10);
	cout << "ret = " << ret << endl;

	//匿名函数对象调用  
	cout << "MyAdd()(100,100) = " << MyAdd()(100, 100) << endl;
}

int main() {

	test01();
	test02();

	system("pause");

	return 0;
}

记住：仿函数非常灵活，没有固定的写法。

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/2747.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

牛客竞赛每日俩题 - 动态规划1

牛客竞赛每日俩题 - 动态规划1

目录 DP入门&#xff08;存储之前状态以简化&#xff09; DP解决最短路问题 DP入门&#xff08;存储之前状态以简化&#xff09; 拆分词句_牛客题霸_牛客网 思路&#xff1a; 方法&#xff1a;动态规划 状态&#xff1a; 子状态&#xff1a;前1&#xff0c;2&#xff0c;3&a…
阅读更多...
蓝桥杯国奖一等奖，经历回顾

蓝桥杯国奖一等奖，经历回顾

文章目录1. 自我介绍2. 参赛经历3. 我的一些经验4. 结语本篇内容为一位粉丝的投稿内容&#xff0c;希望对大家有所帮助。 1. 自我介绍 我是来自一所普通双非的大三学生&#xff0c;以下为主要成绩: 2022蓝桥杯Java组&#xff0c;全国一等奖2022高教社杯全国大学生数学建模竞赛…
阅读更多...
windows一键部署java项目

windows一键部署java项目

前言 前段时间老大看我很闲...然后给我下达了一项很重要的任务&#xff1a;windows一键部署&#xff0c;需要把服务&#xff08;jdk、tomcat、mysql、jar包、前端压缩包&#xff09;打成一个exe应用程序&#xff0c;点击安装会启动所有服务&#xff0c;打开浏览器http://localh…
阅读更多...
Java 程序设计报告[对接java的迭代器接口]

Java 程序设计报告[对接java的迭代器接口]

1&#xff1a;程序的功能设计与分析 -&#xff1a;将实现deque与stack -&#xff1a;采用继承与内部类来提高程序的拓展性、安全性、简洁性 -&#xff1a;对接到java.util.iterator中的iterator接口与iterable接口 2&#xff1a;程序的特点分析 -&#xff1a;观察到队列、栈都…
阅读更多...
二战华为成功上岸，准备了小半年，要个27k应该也算不上很高吧~

二战华为成功上岸，准备了小半年，要个27k应该也算不上很高吧~

先说下我基本情况&#xff0c;本科不是计算机专业&#xff0c;现在是学通信&#xff0c;然后做图像处理&#xff0c;可能面试官看我不是科班出身没有问太多计算机相关的问题&#xff0c;因为第一次找工作&#xff0c;华为的游戏专场又是最早开始的&#xff0c;就投递了&#xf…
阅读更多...
二、肺癌检测-LUNA数据集下载和介绍

二、肺癌检测-LUNA数据集下载和介绍

LUNA数据集是一个肺部肿瘤CT扫描结果的数据集&#xff0c;可用于作为肺癌检测的模型训练。 一、数据集下载 step1&#xff1a;登陆LUNA16官网&#xff0c;链接为&#xff1a;Home - Grand Challenge step2&#xff1a;点击网站左侧【download】&#xff0c;进入下载页面。 s…
阅读更多...
图形学-着色频率与渲染管线

图形学-着色频率与渲染管线

1.着色频率 根据不同的着色方式&#xff0c;有不同的着色频率&#xff0c;主要的着色频率分为三种——面着色&#xff0c;顶点着色和像素着色。主要的不同之处在于法线的选择方式不同。 面着色 Flat Shading指的是计算每一个三角形平面的法线后对一个平面整体进行着色&#x…
阅读更多...
Redo日志和Undo日志

Redo日志和Undo日志

Redo日志和Undo日志Redo日志和Undo日志1 Redo日志和Undo日志概述2 Redo日志2.1 为什么需要Redo日志2.2 Redo日志的好处、特点3 Undo日志3.1 如何理解Undo日志3.2 Undo日志的作用Redo日志和Undo日志 1 Redo日志和Undo日志概述 事务有4种特性&#xff1a;原子性、一致性、隔离性…
阅读更多...
C++类和对象（中）【万字详解】

C++类和对象（中）【万字详解】

这一篇就是C中的类和对象的核心内容了. 目录 类的6个默认成员函数 构造函数 概念 特性 析构函数 概念 特性 拷贝构造函数 概念 特性 赋值运算符重载 运算符重载 赋值运算符重载 const成员 const修饰的类成员函数 8.取地址及const取地址操作符重载 类的6个默认成员函数 如果一个…
阅读更多...
洛谷千题详解 | P1004 [NOIP2000 提高组] 方格取数【C++、Java、Pascal语言】

洛谷千题详解 | P1004 [NOIP2000 提高组] 方格取数【C++、Java、Pascal语言】

博主主页&#xff1a;Yu仙笙 专栏地址&#xff1a;洛谷千题详解 目录 题目描述 输入格式 输出格式 输入输出样例 解析&#xff1a; C源码&#xff1a; Java源码&#xff1a; Pascal源码&#xff1a; ---------------------------------------------------------------------…
阅读更多...
KMP算法模式匹配——手工求解next和nextval数组值

KMP算法模式匹配——手工求解next和nextval数组值

本文需要了解KMP算法基本流程和相关概念&#xff0c;如有问题&#xff0c;请先进行基础学习&#xff1a;链接: 天勤-KMP算法易懂版 求解next数组值 给定模式串&#xff1a;“ababaaab”&#xff0c;求解其next数组值。 例子里面的ababaaab&#xff0c;我们定义一个 i 为模式串的…
阅读更多...
【微服务】Nacos Discovery--服务治理

【微服务】Nacos Discovery--服务治理

Nacos Discovery--服务治理前言服务治理常见的注册中心ZookeeperEurekaConsulNacosNacos 入门搭建nacos环境将商品微服务注册到nacos将订单微服务注册到nacos总结前言 上一章中&#xff0c;我们利用用户–订单–商品&#xff0c;实现了三个简单的微服务&#xff0c;实现了微服…
阅读更多...
如何寻找计算机领域的英文文献？

如何寻找计算机领域的英文文献？

大家一定或多或少都有文献检索的经验吧&#xff0c;中文文献还好&#xff0c;我们总归是对自己的的母语比较熟悉&#xff0c;通过关键词或其他检索条件&#xff0c;总能得心应手地找到自己需要的文献。相较于中文文献&#xff0c;对外文文献的检索就显得难度增加了不少&#xf…
阅读更多...
pthread_create创建线程失败问题排查

pthread_create创建线程失败问题排查

一些基础概念的了解 Android中线程&#xff08;Thread&#xff09;的创建及内存分配过程分析 pthread_create创建线程失败的OOM详解 不可思议的OOM 通过上面的文章&#xff0c;我们知道为什么会报pthread_create错误 在创建线程的时候&#xff0c;报的下面这些错误&#xff0…
阅读更多...
SAP采购订单中的净价是单价还是总价？

SAP采购订单中的净价是单价还是总价？

在采购订单中习惯上我们把订单项目的的净价理解为什么&#xff1f;单价还是总价&#xff1f; 先不着急回答。看看以下两个采购订单的对比截图就能了解&#xff0c; 在4050004000这笔采购订单中&#xff0c;采购10件黄色箱子&#xff0c;每10件500元。所以&#xff0c;净价500…
阅读更多...
《JavaSE-第十七章》之LinkedList

《JavaSE-第十七章》之LinkedList

前言 在你立足处深挖下去,就会有泉水涌出!别管蒙昧者们叫嚷:“下边永远是地狱!” 博客主页&#xff1a;KC老衲爱尼姑的博客主页 博主的github&#xff0c;平常所写代码皆在于此 刷题求职神器 共勉&#xff1a;talk is cheap, show me the code 作者是爪哇岛的新手&#xff0c;水…
阅读更多...
Python Excel导入Mysql的通用方法

Python Excel导入Mysql的通用方法

文章目录一、前言二、实现一、前言 此代码将导入部分尽量通用&#xff0c;仅配置下面两项就可以进行导入了&#xff1a; 从哪个excel导入到哪个mysql表 在程序中配置 他们之间的字段如何对应 写在mysql表中 ps&#xff1a;id&#xff0c;create_time&#xff0c;update_tim…
阅读更多...
基于IDEA创建SpringBoot项目并进行入门分析

基于IDEA创建SpringBoot项目并进行入门分析

基于IDEA创建SpringBoot项目并进行入门分析 文章目录基于IDEA创建SpringBoot项目并进行入门分析SpringBoot 项目创建创建Module项目结构分析SpringBoot 项目启动分析启动入口启动过程概要分析SpringBoot 快速入门分析业务描述API设计分析代码编写及运行运行过程中的BUG分析Spri…
阅读更多...
单商户商城系统功能拆解26—营销中心—限时秒杀

单商户商城系统功能拆解26—营销中心—限时秒杀

单商户商城系统&#xff0c;也称为B2C自营电商模式单店商城系统。可以快速帮助个人、机构和企业搭建自己的私域交易线上商城。 单商户商城系统完美契合私域流量变现闭环交易使用。通常拥有丰富的营销玩法&#xff0c;例如拼团&#xff0c;秒杀&#xff0c;砍价&#xff0c;包邮…
阅读更多...
数电学习（六、时序逻辑电路）（三）

数电学习（六、时序逻辑电路）（三）

文章目录时序逻辑电路的设计方法同步时序逻辑电路的设计方法一般步骤改进步骤例&#xff1a;蚂蚁走迷宫背景分析继续编码状态&#xff0c;然后写出状态图&#xff0c;然后卡诺图化简&#xff0c;得到方程设计总结时序逻辑电路的设计方法 同步时序逻辑电路的设计方法 一般步骤…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023