投稿
  1. 首页
  2. 随笔

C++ 核心篇 7 之类与对象 - 运算符重载

一元一次方程ppt • 2022-10-21 • 随笔 • 阅读 8

C++ 核心篇 7 之类与对象 - 运算符重载,第1张

C++ 核心篇 7 之类与对象 - 运算符重载

C++ 自学
  • 运算符重载
  • 加号运算符重载
  • 左移运算符重载
  • 递增运算符重载
  • 递减运算符重载
  • 赋值运算符重载
  • 关系运算符重载
  • 函数调用运算符重载

运算符重载

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

加号运算符重载

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

#include 
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 
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 
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 
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 
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 
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 
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 
using namespace std;
#include 

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

欢迎分享，转载请注明来源：内存溢出

原文地址: http://outofmemory.cn/zaji/3970212.html

赞 (0)
打赏 微信扫一扫 微信扫一扫 支付宝扫一扫 支付宝扫一扫
一元一次方程ppt 一元一次方程ppt 一级用户组
0 0
上一篇 2022-10-21
下一篇 2022-10-21

发表评论

登录后才能评论

评论列表（0条）

保存