c++关于符号重载

今天复习的主要内容是C++中的符号重载

+号的重载

在c++编译器中，加号被定义为数的相加，但是对于自己创建的内容，想进行相加，编译器的+号是不可以进行运算的，这时候就需要我们进行对加号+进行重新赋予新的意义，即运算符号的重载，

```cpp
#include<iostream>
using namespace std;
//但是现在我们定义了一个person类
class person
{
public:
	//有参构造函数进行赋初值
	person(int a,int b);
	//利用成员函数进行符号的重载
	person& operator+(person &p)
	{
		//创建person的临时变量temp
		person temp(0,0);
		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;
};
person::person(int a,int b)
{
	m_A=a;
	m_B=b;
}
void test01()
{
	//创建两个person的对象
	person p1(10,20);
	person p2(10,30);
	//在没有对+号运算符进行重载之前，这样的操作是行不通的
	//因此，我们对其进行重载
	person p3=p1+p2;
	//这样是不输出不了，这个问题需要一会介绍的左移运算符的重载有关
	//cout<<p3<<endl;
	cout<<p3.m_A<<endl;
	cout<< p3.m_B<<endl;
	
}
//还有一个是全局函数重载也是可以的；
void operator+(person &p1, person &p2)
{
	person temp(0,0);
	temp.m_A=p1.m_A+p2.m_A;
	temp.m_B=p1.m_B+p2.m_B;
}
int main()
{
	//正常的+号运算符，比如
	int a=10;
	int b=20;
	//cout<<a+b<<endl;
	//肯定运算出来的结果是30
	test01();
	system("pause");
	return 0;
	
}

<<左移运算符号的重载

上面的例子中出现了一个这样的问题：
person p3=p1+p2;
cout<<p3<<endl;
cout p3是不能输出的，所以，要对左移运算符进行重载
注意：在对左移运算符号进行重载的时候，是不能运用成员函数进行重载的，利用全局函数进行重载。

#include<iostream>
using namespace std;
//但是现在我们定义了一个person类
class person
{
public:
	//有参构造函数进行赋初值
	person(int a,int b);
	//利用成员函数进行符号的重载
	person& operator+(person &p)
	{
		//创建person的临时变量temp
		person temp(0,0);
		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;
};
person::person(int a,int b)
{
	m_A=a;
	m_B=b;
}
//对左移运算符号进行重载
//只要是person类的调用<<都可以进行输出
ostream & operator<<(ostream&cout,person &p)
{
	cout<<"p的m_A的值为"<<p.m_A<<endl;
	cout<<"p的m_A的值为"<<p.m_B<<endl;
	return cout;
}
void test01()
{
	//创建两个person的对象
	person p1(10,20);
	person p2(10,30);
	//在没有对+号运算符进行重载之前，这样的操作是行不通的
	//因此，我们对其进行重载
	person p3=p1+p2;
	cout<<p3<<endl;
	cout<<p3.m_A<<endl;
	cout<< p3.m_B<<endl;	
	//两个结果显然都是一样的；
}
//还有一个是全局函数重载也是可以的；
/*void operator+(person &p1, person &p2)
{
	person temp(0,0);
	temp.m_A=p1.m_A+p2.m_A;
	temp.m_B=p1.m_B+p2.m_B;
}*/
int main()
{
	test01();
	system("pause");
	return 0;

}

++递增运算符的重载

在C++中，a++和++a的运算都是加1的操作，但是
int a=10;
int b=10;
cout<<++a<<endl;
cout<<b++<<endl;
cout<<b<<endl;
的结果是不一样的，第一个结果是11，而第二个结果是10,第三个结果是11；
那么如果我定义一个自己的类型那么还能进行递增操作吗，根据上面的知识，显然是不可以的，这时我们就需要对递增运算进行重载，来满足我们对自己的类型进行递增或者递减的操作。
首先我定义一个类 myInteger

#include<iostream>
using namespace std;
class myInteger
{
	friend	ostream & operator<<(ostream &cout, myInteger &integer);
	friend void test01();//相当于用了全局函数做友元
	friend void test02();
public:
	//构造一个函数，对其进行赋值
	myInteger(int num)
	{
		m_num = num;
	}
	//利用成员函数对++进行重载
	myInteger& operator++()
	{
		m_num++;
		return *this;//返回的是调用对象的this所对应的值；
	}
	//后置递增运算的重载
	myInteger operator++(int)
	{
		//首先应该记录这个值的初始部分
		myInteger temp = *this;
		//再对这个值进行加+的操作
		m_num++;
		//最后返回这个未经操作的值
		return temp;
	}

private:
	//有一个成员m_num;
	int m_num = 0;
};
//全局函数对<<进行重载
ostream & operator<<(ostream &cout, myInteger &integer)
{
	cout << integer.m_num << endl;
	return cout;
}
void test01()
{
	myInteger integer(10);
	//此处还要进行<<的重载
	cout << integer << endl;
	//在对++运算符重载之前肯定是有问题的，利用成员函数对++进行重载
	cout << ++integer << endl;
}
void test02()
{
	myInteger integer2(20);
	cout << integer2 << endl;
	cout << integer2++ << endl;
}
int main()
{
	//test01();
	test02();
	system("pause");
	return 0;
}