C++类和对象——运算符重载

• • 加号运算符重载
  • 左移运算符重载
  • 递增运算符重载
  • 递减运算符重载

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

加号运算符重载：实现两个自定义数据类型的相加操作。

#include
using namespace std;
//加号运算符重载
class Person {
public:
	
	int m_a;
	int m_b;
};
//2、通过全局函数重载加号
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;
}
//函数重载的版本
//运算符重载也可以发生在函数重载
Person operator+(Person p,int num) {
	Person temp;
	temp.m_a = p.m_a + num;
	temp.m_b = p.m_b + num;
	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.operator+(p2);
	//全局函数调用本质 
	//Person p3 = p1.operator+(p1,p2);
	Person p3 = p1 + p2;
	cout <<"p3的值a为" < 
左移运算符重载 
左移运算符重载：可以输出自定义数据类型。
 
#include
using namespace std;
//重载左移运算符是想直接输出一个对象，重载左移运算符可以配合友元可以实现输出自定义数据类型
class Person {
	friend ostream& operator<<(ostream& cout, Person& p);   //全局函数做友元
public:
	Person(int a,int b) {
		m_a = a;
		m_b = b;
	}
private:
	
	int m_a;
	int m_b;
};
//只能利用全局函数重载左移运算符
//cout全局只能有一个，所以必须用引用的方式传进来，不能创建出来新的一个
ostream & operator<<(ostream &cout,Person &p) {   //本质是operator<<(cout,Person p) 简化版本cout<
 
递增运算符重载 
递增运算符重载：实现对自定义数据类型的递增操作。
 
#include
using namespace std;
//自定义整型类
class Integer {
	friend ostream& operator<<(ostream& cout, Integer myint);   //全局函数做友元
public:
	Integer() {
		m_number = 0;
	}
	//重载前置++运算符 返回引用是为了一直对一个数据进行递增操作
	Integer& operator++() {
		//先进行++运算
		m_number++;
		//再将自身做返回
		return *this;
	}
	//重置后置++运算符 这里的参数int代表占位参数，区分函数重载
	//区分前置后置用占位参数int就可以区分了
	//后置递增一定要返回的是值
	Integer operator++(int) {              //前置递增返回的是引用，后置递增返回的是值!!!!!!!!!!!!!!!!!
		//先记录当前结果
		Integer temp = *this;          //temp是一个局部对象，当前函数执行完temp就被释放掉了，如果引用只能引用一次，再引用第二次就是非法操作
		//再进行递增操作
		m_number++;
		//最后将记录结果作返回
		return temp;

	}
private:
	int m_number;
};
//重载左移运算符
ostream &operator<<(ostream &cout,Integer myint) {
	cout << myint.m_number << endl;
	return cout;
}


void test01() {     //++a操作  前置递增
	Integer myint;
	cout << ++(++myint)< 
递减运算符重载 
递减运算符重载：实现对自定义数据类型的递减操作。
 
#include
using namespace std;
class Myinteger {
	friend ostream& operator<<(ostream& cout, Myinteger myint);//左移运算符函数做友元，访问私有属性

public:
	Myinteger() {
		m_number = 10;
	}
	//重载前置递减运算符
	Myinteger &operator--() {
		//先递减
		m_number--;
		//再返回结果
		return *this;
	}
	//重载后置递增运算符
	Myinteger operator--(int) {         //int做占位参数来区分函数重载
		//先返回当前值
		Myinteger temp = *this;
		//再进行递减操作
		m_number--;
		//最后将记录的结果返回
		return temp;
	}
private:
	int m_number;
};
//重载左移运算符
ostream& operator<<(ostream & cout,Myinteger myint) {
	cout << myint.m_number << endl;
	return cout;
}

void test01() {   //前置递减 --a操作
	Myinteger myint;
	cout << --myint << endl;
	cout << myint << endl;
}
void test02() {  //后置递减  a--操作
	Myinteger myint;
	cout << myint-- << endl;
	cout << myint << endl;
}
int main() {
	test01();
	test02();
	system("pause");
	return 0;
}