【C++核心编程 4】——类和对象——4.5 运算符重载[ 加号 / 左移＜＜ / 递增 / 赋值 / 关系 / 函数调用 ]

于 2023-02-09 22:51:00 发布
阅读量128 收藏
点赞数
分类专栏： C++学习 文章标签： c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/mycsdn3657/article/details/128955034
版权

4.5 运算符重载

运算符重载概念：对已有的运算符重新进行定义，赋予其另一种功能，以适应不同的数据类型


4.5.1 加号运算符重载

作用：实现两个自定义数据类型相加的运算
在这里插入图片描述

通过自己写成员函数，实现两个对象相加属性后返回新的对象

Person PersonAddPerson(Person &p){
  Person temp;
  temp.m_a=this.m_a+p.m_a;
  temp.m_b=this.m_b+p.m_b;
  return temp;
}

编译器给起了一个通用名称operator+。

通过成员函数重载了加号：

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;
}

//本质
Person p3=p1.operator+(p2);
//简化为
Person p3=p1+p2;

成员函数 + 号重载

示例：

#include<iostream>
using namespace std;
class Person {
public:
	//成员函数运算符重载
	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;
};
void test01() {
	Person p1;
	p1.m_a = 10;
	p1.m_b = 10;
	Person p2;
	p2.m_a = 20;
	p2.m_b = 30;
  
	//本质：Person p3 = p1.operator+(p2);
	Person p3 = p1 + p2;
  
	cout << "p3.m_a=" << p3.m_a << ", p3.m_b=" << p3.m_b << endl;
}
int main() {
	test01();
	return 0;
}

全局函数 + 号重载
#include<iostream>
using namespace std;
class Person {
public:
	int m_a;
	int m_b;
};

//全局函数运算符重载
Person operator+(Person& p1,Person &p2) {
	Person temp;
	temp.m_a = p1.m_a + p2.m_a;
	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 = 20;
	p2.m_b = 30;

	//本质：Person p3 = operator+(p1,p2);
	Person p3 = p1 + p2;

	cout << "p3.m_a=" << p3.m_a << ", p3.m_b=" << p3.m_b << endl;
}
int main() {
	test01();
	return 0;
}

运算符重载也可发生函数重载
#include<iostream>
using namespace std;
class Person {
public:
	int m_a;
	int m_b;
};

//函数重载
Person operator+(Person& p1, int num) {
	Person temp;
	temp.m_a = p1.m_a + num;
	temp.m_b = p1.m_b + num;
	return temp;
}
void test01() {
	Person p1;
	p1.m_a = 10;
	p1.m_b = 10;
	Person p2;
	p2.m_a = 20;
	p2.m_b = 30;

	Person p3 = p1 + 100;//Person + int

	cout << "p3.m_a=" << p3.m_a << ", p3.m_b=" << p3.m_b << endl;
}
int main() {
	test01();
	return 0;
}

总结：

  1. 对于内置的数据类型的表达式的运算符是不可能改变的
  2. 不要滥用运算符重载

4.5.2 左移运算符重载

作用：可以输出自定义数据类型

不会利用成员函数重载 << 运算符

因为无法实现 cout在左侧

class Person {
public:
	//利用成员函数重载左移运算符
	//p.operator<<(cout)  简化 p<<cout
	/*void operator<<(cout) {

	}*/
	//故不会利用成员函数重载 << 运算符，因为无法实现 cout 在左侧
	Person(int a, int b) {
		m_a = a;
		m_b = b;
	}
	int m_a;
	int m_b;
};

只能利用全局函数实现左移重载
#include<iostream>
using namespace std;
class Person {
  //友元   全局函数做友元
	friend ostream& operator<<(ostream& out, Person& p);
public:
	Person(int a, int b) {
		m_a = a;
		m_b = b;
	}
private:
	int m_a;
	int m_b;
};
//全局函数实现左移重载
//本质 operator << (cout,p)  简化 cout<<p
//ostream 是标准输出流类，全局只能有一个 cout,只能用引用的方式 &cout
ostream& operator<<(ostream &out,Person& p) {
	out << "m_a=" << p.m_a << ",m_b=" << p.m_b;
	return out;//返回 ostream&，则可进行链式输出
}
void test01() {
	Person p(10, 20);
	cout << p << endl;
}
int main() {
	test01();
	return 0;
}

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


4.5.3 递增运算符重载

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

内置的递增操作：

int a=10;
//前置递增
cout<<++a<<endl;//11
cout<<a<<endl;//11

//后置递增
int b=10;
cout<<b++<<endl;//10
cout<<b<<endl;//11

#include<iostream>
using namespace std;
class MyInteger {
	friend ostream& operator<<(ostream& cout, MyInteger myInt);
public:
	MyInteger() {
		m_Num = 0;
	}
	//重载前置++运算符 返回的是引用
	//返回引用是为了一直对一个数据进行递增操作
	MyInteger &operator++() {
		m_Num++;//先做++运算
		return *this;//再将自身做返回
	}
	//重载后置++运算符 返回的是值
	//operator++(int) int代表占位参数，可以用于区分前置递增和后置递增
	MyInteger operator++(int) {
		//先记录当前的结果
		MyInteger temp = *this;
		//后递增
		m_Num++;
		//最后记录结果做返回     让本身的值递增但返回先前的值，达到先返回再递增
		return temp;
	}
private:
	int m_Num;
};
//重载左移运算符
ostream& operator<<(ostream& cout, MyInteger myInt) {
	cout << myInt.m_Num;
	return cout;
}
void test01() {
	MyInteger mi;
	cout << ++mi << endl;//1
	cout << mi << endl;//1
}
void test02() {
	MyInteger mi;
	cout << mi++ << endl;//0
	cout << mi << endl;//1
}
int main() {
	test01();
	test02();
	return 0;
}

4.5.4 赋值运算符重载

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

  1. 默认构造函数（无参，函数体为空）
  2. 默认析构函数（无参，函数体为空）
  3. 默认拷贝构造函数，对属性进行值拷贝
  4. 赋值运算符operator=，对属性进行值拷贝

如果类中有属性指向堆区，做赋值操作时也会出现深浅拷贝问题

示例：

#include<iostream>
using namespace std;

class Person {
public:
	Person(int age) {
		//将数据开辟在堆区，并用指针进行维护
		m_age = new int(age);
	}

	~Person() {
		if (m_age != NULL) {
			delete m_age;
			m_age = NULL;
		}
	}

	//重载赋值运算符
	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;//返回对象自身
	}

	int *m_age;
};

void test01() {
	Person p1(18);
	Person p2(20);
	Person p3(25);

	//p2=p1; 编译器提供的赋值操作出现浅拷贝问题，导致堆区数据进行重复释放
	p3 = p2 = p1;
	cout << *p1.m_age << endl;
	cout << *p2.m_age << endl;
	cout << *p3.m_age << endl;
}

int main() {
	test01();

	return 0;
}

4.5.5 关系运算符重载

作用：可以让两个自定义类型对象进行对比操作

#include<iostream>
#include<string>
using namespace std;
class Person {
public:
	Person(string name, int age) {
		p_name = name;
		p_age = age;
	}
	~Person() {

	}
	//重载等号
	bool operator==(Person &p) {
		if (this->p_name == p.p_name && this->p_age == p.p_age) {
			return true;
		}
		return false;
	}
	//重载不等号
	bool operator!=(Person& p) {
		if (this->p_name == p.p_name && this->p_age == p.p_age) {
			return false;
		}
		return true;
	}
	string p_name;
	int p_age;

};
void test01() {
	Person p1("张三", 12);
	Person p2("张三", 12);

	if (p1 == p2) {
		cout << "p1与p2是相等的" << endl;
	}
	else {
		cout << "p1与p2不相等" << endl;
	}

	Person p3("tom", 15);
	Person p4("Jerry", 15);

	if (p3 != p4) {
		cout << "p3与p4是不相等的" << endl;
	}
	else {
		cout << "p3与p4是相等的" << endl;
	}
}
int main() {
	test01();
	return 0;
}

4.5.6 函数调用运算符重载

  • 函数调用运算符()也可以重载
  • 由于重载后使用的方式非常像函数的调用，因此称为仿函数
  • 仿函数没有固定写法，非常灵活
#include<iostream>
#include<string>
using namespace std;
//函数调用运算符重载
class MyPrint {
public:
	//重载()
	void operator()(string test){
		cout << test << endl;
	}
};
void MyPrint02(string test) {
	cout << test << endl;
}
void test01() {
	MyPrint mp;
	mp("hello world!");//由于使用起来非常类似于函数调用，因此称为仿函数
	
	MyPrint02("hello world");

}
//仿函数非常灵活，没有固定写法
class MyAdd {
public:
	int operator()(int num1, int num2) {
		return num1 + num2;
	}
 };
void test02() {
	MyAdd ma;
	int ret = ma(20, 40);
	cout << ret << endl;//60

	//匿名函数对象
	cout << MyAdd()(100, 200) << endl;//当前函数执行完毕，释放匿名对象
}

int main() {
	test01();
	test02();
	return 0;
}
mycsdn3657
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值