脚本之家 服务器常用软件
快捷导航
您的位置：首页 → 软件编程 → C 语言 → C++类与对象之运算符重载

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

 更新时间：2021年10月18日 09:55:55   作者：是我来晚了！  
运算符重载的方法是定义一个重载运算符的函数，在需要执行被重载的运算符时，系统就自动调用该函数，以实现相应的运算。也就是说，运算符重载是通过定义函数实现的

运算符重载

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

加号运算符重载

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

#include <iostream>
using namespace std;
class Person {
public:
	// 构造函数
	Person(int num1, int num2){
		this->num1 = num1;
		this->num2 = num2;
	}
	// 加法函数
	Person operator+(const Person &p){
		Person temp(0, 0);
		temp.num1 = this->num1 + p.num1;
		temp.num2 = this->num2 + p.num2;
		return temp;
	}
	// 打印输出
	void printMessage() {
		cout << "num1 = " << num1 << " num2 = " << num2 << endl;
	}
private:
	int num1;
	int num2;
};
void func() {
	Person p1(1, 2);
	Person p2(3, 4);
	Person p3 = p1.operator+(p2); // 可以简化为 Person = p1 + p2;
	p3.printMessage(); // num1 = 4 num2 = 6
	Person p4 = p3 + p2;
	p4.printMessage(); // num1 = 7 num2 = 10
}
int main() {
	func();
	system("pause");
	return 0;
}

左移运算符重载

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

第一种：成员函数（对象 << cout）

#include <iostream>
using namespace std;
class Person {
public:
	// 构造函数
	Person(int num1, int num2){
		this->num1 = num1;
		this->num2 = num2;
	}
	// 左移运算符 p.operator<<(cout); 简化版本 p << cout
	void operator <<(ostream &cout) {
		cout << "num1 = " << num1 << " num2 = " << num2 << endl;
	}
private:
	int num1;
	int num2;
};
void func() {
	Person p1(1, 2);
	p1.operator<<(cout); // 简化为 p1 << cout
	Person p2(3, 4);
	p2 << cout;
}
int main() {
	func();
	// outputs:num1 = 1 num2 = 2
	//		   num1 = 3 num2 = 4
	system("pause");
	return 0;
}

第二种：全局函数（cout << 对象）

#include <iostream>
using namespace std;
class Person {
	// 友元
	friend ostream& operator <<(ostream &cout, Person &p);
public:
	// 构造函数
	Person(int num1, int num2){
		this->num1 = num1;
		this->num2 = num2;
	}
private:
	int num1;
	int num2;
};
// 左移运算符 p.operator<<(cout); 简化版本 p << cout
ostream& operator <<(ostream &cout, Person &p) {
	cout << "num1 = " << p.num1 << " num2 = " << p.num2;
	return cout;
}
void func() {
	Person p1(1, 2);
	operator<<(cout, p1); // 简化为 cout << p1;
	cout << endl;
	cout << p1 << " 你是猪！" << endl;
}
int main() {
	func();
	// outputs:num1 = 1 num2 = 2
	//		   num1 = 1 num2 = 2 你是猪！
	system("pause");
	return 0;
}

递增运算符重载

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

#include <iostream>
using namespace std;
class MyInteger {
	//friend ostream& operator <<(ostream &cout, MyInteger &p);
	friend ostream& operator <<(ostream &cout, MyInteger p);
public:
	// 构造函数
	MyInteger(){
		this->m_num = 0;
	}
	// 重载前置递增运算符
	MyInteger& operator++() {
		++this->m_num;
		return *this;
	}
	// 重载后置递增运算符
	MyInteger operator++(int) { // int 是占位参数，用于区分前置和后置递增
		MyInteger temp = *this;
		++this->m_num;
		return temp;
	}
private:
	int m_num;
};
// 用于前置递增，左移运算符 p.operator<<(cout); 简化版本 p << cout
//ostream& operator <<(ostream &cout, MyInteger &p) {
//	cout << "m_num = " << p.m_num;
//	return cout;
//}
// 用于后置递增，左移运算符 p.operator<<(cout); 简化版本 p << cout
ostream& operator <<(ostream &cout, MyInteger p) {
	cout << "m_num = " << p.m_num;
	return cout;
}
void func() {
	MyInteger m_int;
	//cout << m_int.operator++() << endl; // m_num = 1
	//cout << ++m_int << endl; // m_num = 2
	cout << m_int++ << endl; // m_num = 0
	cout << m_int << endl; // m_num = 1
}
int main() {
	func();
	system("pause");
	return 0;
}

递减运算符重载

通过重载递减运算符，实现自己的整型数据

#include <iostream>
using namespace std;
class MyInteger {
	friend ostream& operator <<(ostream &cout, MyInteger &p);
	//friend ostream& operator <<(ostream &cout, MyInteger p);
public:
	// 构造函数
	MyInteger(){
		this->m_num = 0;
	}
	// 重载前置递减运算符
	MyInteger& operator--() {
		--this->m_num;
		return *this;
	}
	// 重载后置递减运算符
	MyInteger operator--(int) { // int 是占位参数，用于区分前置和后置递增
		MyInteger temp = *this;
		--this->m_num;
		return temp;
	}
private:
	int m_num;
};
// 用于前置递减，左移运算符 p.operator<<(cout); 简化版本 p << cout
ostream& operator <<(ostream &cout, MyInteger &p) {
	cout << "m_num = " << p.m_num;
	return cout;
}
// 用于后置递减，左移运算符 p.operator<<(cout); 简化版本 p << cout
//ostream& operator <<(ostream &cout, MyInteger p) {
//	cout << "m_num = " << p.m_num;
//	return cout;
//}
void func() {
	MyInteger m_int;
	cout << m_int.operator--() << endl; // m_num = -1
	cout << --m_int << endl; // m_num = -2
	//cout << m_int-- << endl; // m_num = 0
	//cout << m_int << endl; // m_num = -1
}
int main() {
	func();
	system("pause");
	return 0;
}

赋值运算符重载

C++ 编译器至少给一个类添加 4 个函数（此处不举例，具体可见核心篇 5）

#include <iostream>
using namespace std;
class Student {
public:
	// 构造函数
	Student(int id) {
		m_id = new int(id); // 从堆区开辟内存用来存储 id
	}
	// 拷贝构造函数
	Student(const Student &s) {
		this->m_id = new int(*s.m_id);
	}
	// 析构函数
	~Student() {
		if (m_id != NULL) {
			delete m_id;
			m_id = NULL;
		}
	}
	// 重载赋值运算符
	Student& operator=(Student &s) {
		if (m_id != NULL) {
			delete m_id;
			m_id = NULL;
		}
		m_id = new int(*s.m_id);
		return *this;
	}
	// 取出 id
	int getId() {
		return *m_id;
	}
private:
	int *m_id;
};
void func() {
	Student s1(1);
	cout << s1.getId() << endl; // 1
	// 用拷贝构造函数来作深拷贝
	Student s2(s1);
	cout << s2.getId() << endl; // 1
	// 用赋值重载运算符来作赋值
	Student s3(2); // id 为 2
	s1 = s3; // 复杂版本：s1.operator=(s3)
	cout << s1.getId() << endl; // 2
	// 多段赋值运算符，例如 a = b = c
	Student s4(3);
	s1 = s2 = s3 = s4; // id 均为 3
	cout << s1.getId() << s2.getId() << s3.getId() << s4.getId() << endl; // 3333
}
int main() {
	func();
	system("pause");
	return 0;
}

关系运算符重载

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

#include <iostream>
using namespace std;
class Student {
public:
	// 构造函数
	Student(int id) {
		m_id = new int(id); // 从堆区开辟内存用来存储 id
	}
	// 拷贝构造函数
	Student(const Student &s) {
		this->m_id = new int(*s.m_id);
	}
	// 析构函数
	~Student() {
		if (m_id != NULL) {
			delete m_id;
			m_id = NULL;
		}
	}
	// 重载 == 运算符
	bool operator==(Student &s) {
		if (this->getId() == s.getId()) {
			return true;
		}
		else {
			return false;
		}
	}
	// 取出 id
	int getId() {
		return *m_id;
	}
private:
	int *m_id;
};
void func() {
	Student s1(1);
	Student s2(1);
	Student s3(2);
	if (s1 == s2) {
		cout << "s1 和 s2 相等" << endl;
	}
	if (s1 == s3) {
		cout << "s1 和 s3 相等" << endl;
	}
	else {
		cout << "s1 和 s3 不相等" << endl;
	}
}
int main() {
	func();
	// outputs:s1 和 s2 相等
	//		   s1 和 s3 不相等
	system("pause");
	return 0;
}

函数调用运算符重载

特点：函数调用运算符 () 也可以重载；重载后调用的方式很像函数，被称为仿函数；没有固定写法，非常灵活

#include <iostream>
using namespace std;
#include <string>
class Print {
public:
	void operator()(string text) {
		cout << "利用函数调用重载运算符打印输出：" << text << endl;
	}
};
void func() {
	Print p1;
	p1("你是一个小猪猪！"); // 利用函数调用重载运算符打印输出：你是一个小猪猪！
}
int main() {
	func();
	// outputs:s1 和 s2 相等
	//		   s1 和 s3 不相等
	system("pause");
	return 0;
}

总结

本篇文章就到这里了，希望能够给你带来帮助，也希望您能够多多关注脚本之家的更多内容！

您可能感兴趣的文章:

相关文章

  • C++回溯与分支限界算法分别解决背包问题详解

    C++回溯与分支限界算法分别解决背包问题详解

    给定n种物品和一背包。物品i的重量是wi，其价值为vi，背包的容量为C。问应如何选择装入背包的物品，使得装入背包中物品的总价值最大？下面我们分别用回溯与分支限界方法解决
    2022-06-06
  • C++有限状态机实现计算器小程序

    C++有限状态机实现计算器小程序

    这篇文章主要为大家详细介绍了C++有限状态机实现计算器小程序的相关资料，文中示例代码介绍的非常详细，具有一定的参考价值，感兴趣的小伙伴们可以参考一下
    2017-06-06
  • 详解C++中static的用法

    详解C++中static的用法

    这篇文章主要介绍了c++中static的用法详解,C 语言的 static 关键字有三种用途，具体内容详情大家跟随脚本之家小编一起学习吧
    2018-05-05
  • C++瓦片地图坐标转换的实现详解

    C++瓦片地图坐标转换的实现详解

    常见的瓦片地图有矩形、菱形、正六边形几种。此文章主要讨论菱形瓦片，也就是大家常说的2.5D，斜45度瓦片地图。比如《红警2》、《帝国时代2》都是采用这种技术
    2022-09-09
  • C++实现LeetCode(61.旋转链表)

    C++实现LeetCode(61.旋转链表)

    这篇文章主要介绍了C++实现LeetCode(61.旋转链表),本篇文章通过简要的案例,讲解了该项技术的了解与使用,以下就是详细内容,需要的朋友可以参考下
    2021-07-07
  • C++11 constexpr使用详解

    C++11 constexpr使用详解

    constexpr是一种比const 更严格的束缚, 它修饰的表达式本身在编译期间可知, 并且编译器会尽可能的 evaluate at compile time，本文重点给大家介绍C++11 constexpr使用,需要的朋友可以参考下
    2021-12-12
  • 详解C语言整数和浮点数在内存中的存储

    详解C语言整数和浮点数在内存中的存储

    这篇文章主要介绍了C语言整数和浮点数在内存中是如何存储的,文中有详细的代码示例供大家参考,对大家了解学习C语言整数和浮点数在内存中的存储有一定的帮助,需要的朋友可以参考下
    2024-03-03
  • C语言中获取和改变目录的相关函数总结

    C语言中获取和改变目录的相关函数总结

    这篇文章主要介绍了C语言中获取和改变目录的相关函数总结,包括getcwd()函数和chdir()函数以及chroot()函数的使用方法,需要的朋友可以参考下
    2015-09-09
  • C语言实现英文单词助手

    C语言实现英文单词助手

    这篇文章主要为大家详细介绍了C语言实现单词小助手，文中示例代码介绍的非常详细，具有一定的参考价值，感兴趣的小伙伴们可以参考一下
    2019-10-10
  • C语言实现飞机游戏(2)

    C语言实现飞机游戏(2)

    这篇文章主要介绍了C语言实现飞机游戏的第二部分，进行功能完善，文中示例代码介绍的非常详细，具有一定的参考价值，感兴趣的小伙伴们可以参考一下
    2022-05-05

最新评论