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

已于 2023-01-03 19:12:04 修改
阅读量1.3k 收藏 7
点赞数 2
分类专栏： 系统性学习C++ 文章标签： c++ 开发语言 蓝桥杯 windows
于 2022-11-01 17:16:21 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_62853489/article/details/127632455
版权

目录

🤡加号运算符重载

🤡左移运算符重载

🤡递增运算符重载

🤡递减运算符重载

🤡赋值运算符重载

🤡关系运算符重载

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

🤡加号运算符重载

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

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

使用运算符重载（注意：重载函数名必须是编译器提供的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;
}

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

幸福西西弗斯
关注
  • 2
    点赞
  • 踩
  • 7
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
C++重载运算符的规则详解
12-31
（1）C++不允许用户自己定义新的运算符，只能对已有的C++运算符进行重载。例如，有人觉得BASIC中用“* *”作为幂运算符很方便，也想在C++中将“* *”定义为幂运算符，用“3* *5”表示35，这是不行的。 （2）C++允许重载的运算符C++中绝大部分运算符都是可以被重载的。 不能重载的运算符只有5个： .             （成员访问运算符） .*            （成员指针访问运算符） ::             （域运算符） sizeof    （长度运算符） ?:            （条件运算符） 前两个运算符不能重载是为了保证访问成员的功能不能被改变，域运算
【c++】类和对象6—运算符重载
FishC的博客
02-22 249
【c++】类和对象6—运算符重载
c++中运算符重载方式中你易遗漏的小细节
qq_39838607的博客
01-26 473
运算符重载函数相当于类来说有两种存在方式： 1.重载为类的成员函数。 2.重载为类的友元函数。 重载为类的成员函数。 如果把运算符重载为类的成员函数,则该函数么须通过对象调用,该对象就是运算符的其中一个操作数,在运算符重载函数中通过this指针隐含(或显式)地访问对象的成员。 如果把双目运算符重载为类的成员函数,则该运算符有两个操作数,左操作数是调用运复符重载函数的对象,而右操作数作为运算符重载函数的实参传递到运算符重载函数中双目运算符重载为类的成员函数时,其调用的一般格式如下： **左操作数 运算.
黑马程序员-------运算符重载(一)
guoguo_19900310的专栏
11-14 581
---------------------- http://edu.csdn.net"target="blank">ASP.Net+Android+IOS开发、<a href="http://edu.csdn.net"target="blank">.Net培训、期待与您交流！ ---------------------- 运算符重载就是重新定义运算符的功能。在你自定义的类中，
C++研发 核心篇 第四讲 【4.5 运算符重载】
Kukeoo的博客
02-12 99
4.5 运算符重载 运算符重载概念：对已有的运算符重新进行定义，赋予其另一种功能，以适应不同的数据类型 4.5.1 加号运算符重载 作用：实现两个自定义数据类型相加的运算 class Person { public: Person() {}; Person(int a, int b) { this->m_A = a; this->m_B = b; } //成员函数实现 + 号运算符重载 Person operator+(const Person& p) {
黑马程序员----运算符重载
d317356845的专栏
02-22 331
---------------------- Windows Phone 7手机开发、.Net培训、期待与您交流！ ----------------------     运算符的重载是C#中一个重要的功能，使得实际操作带来巨大直观易懂的便利。 像+和*这样的运算符只能用于预定义的数据类，原因很简单：编译器认为所有常见的运算符都是用于这些数据类型；例如，它知道如何让把两个long类型数据加起
黑马教程学习笔记——运算符重载
weixin_51520361的博客
07-18 93
1、加号运算符重载 #include<iostream> #include <string> using namespace std; 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;
对象-运算符重载
斯人若彩虹，遇上方知有！
09-04 166
content: 函数解决运算 运算符重载 重载单目运算符 两个对象的相加的实现 1、函数解决运算 #include<iostream> using namespace std; //注意事项： //1、不允许用户自定义新的运算符，只能对已有的运算符进行重载 //2、不能改变原有的运算符操作数的个数 //3、不能改变原有运算符的等级 //4、不能改变原有运算符的结合性 //...
详解C++编程中的单目运算符重载与双目运算符重载
01-20
C++单目运算符重载 单目运算符只有一个操作数，如!a，-b，&c，*p，还有最常用的++i和–i等。重载单目运算符的方法与重载双目运算符的方法是类似的。但由于单目运算符只有一个操作数，因此运算符重载函数只有一个参数...
详解C++编程中的重载流插入运算符和流提取运算符
01-20
”和“>>”进行了重载，使之作为流插入运算符和流提取运算符，能用来输出和输入C++标准类型的数据。因此，凡是用“cout<<”和“cin>>”对标准类型数据进行输入输出的，都要用#include 把头文件包含到本程序...
C++运算符重载 成员函数与友元函数详解
12-31
代码如下:#include<iostream>using namespace std;class A{ int x,y; public: A(int xx,int yy):x(xx),y(yy){} A(){x=0;y=0;} A operator+(const A&b) //不加const限定，也可以 { return A(x+b.x,y+b.y);...
C++运算符重载规则详解
12-31
C++允许重载的运算符和不允许...C++运算符重载的规则 C++对运算符重载定义了如下几条规则。 1) C++不允许用户自己定义新的运算符，只能对已有的C++运算符进行重载。 例如，有人觉得BASIC中用“**“作为幂运算符很方便
黑马程序员-------运算符重载（三）
guoguo_19900310的专栏
11-14 561
---------------------- http://edu.csdn.net"target="blank">ASP.Net+Android+IOS开发、<a href="http://edu.csdn.net"target="blank">.Net培训、期待与您交流！ ---------------------- 转换运算符的重载，其中的关键字是implicit （隐式转换）
C++ 对象运算符重载
Claroja
04-02 444
对象运算符重载
类中赋值运算符重载函数
weixin_30448603的博客
04-29 177
声明一个字符串类，为这个类型添加赋值运算符 class MyString { public: //构造函数 MyString(char* pData = NULL); //构造函数 MyString(const MyString& str); //析构函数 ~MyString(void); //赋值运算符 MyString&a...
C++ 自定义比较：仿函数、函数与重载操作符
Life runs on code
04-04 5532
cpp 模板泛型编程 cpp 比 c 方便不少不光因为其支持面向对象支持class，同样还因为其支持泛型编程，有方便的STL库。泛型要比宏强大的多，是一种设计更巧妙的编译期动态机制，类型安全，使得一些通用算法的封装变得十分方便。模板操作的是类型，特化的时候编译器会做类型推导，这是模板一个核心特征。 根据C++标准，当一个模板不被用到时它就不应该被具体化。对于cpp 编译器是如何特化，编译成最终...
初识c++（14）之仿函数（function-like class）和像指针的类（pointer-like class）"()"和“->”和“*”的重载
请叫我少爷的博客
07-24 418
仿函数（function-like class） 仿函数就是一种看起来就像是函数的类，其实是对“（）”的重载。 class Func{ public: void operator() (const string& str) const { cout<<str<<endl; } }; in...
C++仿函数和()运算符重载
idwtwt的专栏
05-16 1939
群上一网友贴了一段类似仿函数用法，问大家什么意思。如下：大家说了一通，结果提问人说代码错了，氛围有点尴尬。。。哈哈。笑完之后，借着这个机会整理下。1）仿函数定义仿函数(functor)，就是使一个类的使用看上去象一个函数。其实现就是类中实现一个operator()，这个类就有了类似函数的行为，就是一个仿函数类了。2）实现例子#include &lt;iostream&gt; using na...
C++ 容器（二）——容器操作
最新发布
weixin_56362288的博客
05-09 329
1、动态数组Vector没有提供头部增删（push_front()、pop_front()）功能（和数组一样，删除除尾部索引的需要修改后面元素的索引值，很繁琐），链表list有。代码示例：通过上述函数，实现动态数组vector的增删改查。
c++ 运算符重载详解
08-15
C++ 中的面向对象编程允许我们使用类和对象来组织和管理代码。在类中，可以定义成员函数和成员变量。成员函数是与类相关联的函数，它们可以访问类的成员变量并执行与该类相关的操作。成员变量是存储在类中的变量，...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

幸福西西弗斯

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

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

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

打赏作者

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

抵扣说明：

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

余额充值