左移运算符重载：
1.不要乱用运算符重载
2.内置数据类型的运算符 不可重载
3.cout << 直接对Person自定义数据类型， 进行输出
4.写道全局函数中 ostream& operator<<(ostream& cout, Person& p1);
5.如果重载时想访问 p1 的私有属性，那么全局函数要做Person的友元函数

#include<iostream>
using namespace std;


class Person
{

	friend ostream& operator<<(ostream& cout, Person& p1);

public:
	Person() {}
	Person(int a, int b)
	{
		this->m_A = a;
		this->m_B = b;
	}

	/*
	* //重载左移运算符不可以写到成员函数中
	* 原因：
	*如果让成员函数重载，调用的方法必须是形如：p1 << ,而不能用cout <<
	void operator<<()
	{

	}
	*/
private:
	int m_A;
	int m_B;

};
//cout 属于 ostream 类型
//要保证全局只有一个cout，不要自己创建一个新的cout，所以用引用的方式传参
//cout << 直接对Person数据类型进行输出
ostream& operator<<(ostream &cout,Person & p1)//第一个参数：cout，第二个参数：p1
{
	cout << "m_A = " << p1.m_A << " m_B = " << p1.m_B << endl;
	return cout;
}


void test01()
{
	Person p1(10, 10);

	//需求：cout << p1 << endl; 这行代码能直接而输出 p1.m_A 和 p1.m_B 的值
	cout << p1;//重写后的 << 返回值是void，就变成了void << endl;
	//因此，返回值是void不太合适，需要return 一个 ostream的引用：ostream &
	//此时，把int m_A和int m_B都写成私有的
 
	//那样的话，这个函数就用不了了，
	// ostream& operator<<(ostream & cout, Person & p1)//第一个参数：cout，第二个参数：p1
	//{
	//	cout << "m_A = " << p1.m_A << " m_B = " << p1.m_B << endl;
	//	return cout;
	//}

	cout << p1 << "哈哈" << endl;

	//有没有一种方法，可以在全局函数内访问到这个函数的私有属性？ 当然有，那就是——友元！！！
}

int main()
{
	test01();

	system("pause");
	return 0;
}

加号运算符重载：
1.使用成员函数的方式	
2.使用全局函数的方式
 p1.operator+(p2)(调用成员方法) operator+(p1,p2)（调用全局方法）

#include<iostream>
using namespace std;

int a = 10;
int b = 10;
int c = a + b;

class Person
{
public:
	Person() {}
	Person(int a, int b) :m_A(a), m_B(b) {}

	//使用 + 运算符重载:
	//1.成员函数的方式
	//Person operator+(Person &p)//二元，成员函数没有参数是 一元
	//{
	//	Person tmp;//要调用默认构造，而默认构造已经被有参构造取代了，因此要重新提供一下
	//	tmp.m_A = this->m_A + p.m_A;
	//	tmp.m_B = this->m_B + p.m_B;
	//	return tmp;
	//}

	int m_A;
	int m_B;
};

//利用全局函数进行 + 运算符的重载
Person operator+(Person& p1, Person& p2)//二元：针对形参列表的个数
{
	Person tmp;
	tmp.m_A = p1.m_A + p2.m_A;
	tmp.m_B = p1.m_B + p2.m_B;

	return tmp;
}

//利用全局函数进行 + 运算符的重载
Person operator+(Person& p1, int a)//二元：针对形参列表的个数
{
	Person tmp;
	tmp.m_A = p1.m_A + a;
	tmp.m_B = p1.m_B + a;

	return tmp;
}

void test01()
{
	Person p1(1, 1);
	Person p2(1, 1);

	//Person p3 = p1 + p2;//编译器是不知道如何让两个Person类型进行运算的
	
	Person p3 = p1 + p2;//p1 + p2从什么表达式转变的？p1.operator+(p2)(调用成员方法) operator+(p1,p2)（调用全局方法）
	Person p3 = p1 + 10;//重载的版本
	cout << "p3 的 m_A：" << p3.m_A << endl;
	cout << "p3 的 m_B：" << p3.m_B << endl;

}

int main()
{
	test01();

	system("pause");
	return 0;
}

#include<iostream>
using namespace std;



class MyInteger
{

	friend ostream& operator<<(ostream& cout, MyInteger& p1);
public:
	MyInteger()
	{
		m_Num = 0;
	}
	//前置++重载
	MyInteger & operator++()
	{
		this->m_Num++;
		return *this;
	}

	//后置++重载
	MyInteger operator++(int)//这就是占位参数的唯一用处
	{
		//先使用临时数据，保存一下目前的值
		MyInteger tmp = *this;
		m_Num++;
		return tmp;
	}

	int m_Num;
};


ostream& operator<<(ostream & cout,MyInteger & myInt)
{
	cout << myInt.m_Num << endl;
	return cout;
}


void test01()
{
	MyInteger myInt;
	//++myInt;//前置++ //error只要用的是编译器不认的运算符，都会报：没有与这些操作符匹配的 "某某" 运算符
	//++myInt;
	//myInt++;//后置++

	cout << ++myInt << endl;//error只要用的是编译器不认的运算符，都会报：没有与这些操作符匹配的 "某某" 运算符
	cout << myInt++ << endl;//仅仅这样的话，这里会报错
//报错的原因是：
//MyInteger operator++(int)函数返回的是一个临时对象，临时对象‘一般'不能被修改
//但是C++11引入右值引用 && 之后，临时对象也是可以被修改的
//因此，左值引用（即非常量对象引用）不能绑定临时变量，而常量函数引用可以绑定临时对象。
//即，要把
	/*
改  ostream& operator<<(ostream & cout,MyInteger & myInt)
为  ostream& operator<<(ostream & cout,const MyInteger & myInt)
*/
}

int main()
{
	test01();

	system("pause");
	return 0;
}





1.前置++为什么要返回引用？
当把
	//前置++重载
	MyInteger operator++()
	{
		this->m_Num++;
		return *this;
	}

返回值改为MyInteger 的时候，

	cout << ++(++myInt) << endl;//2
	cout << myInt << endl;//1
原因：
因为，此时返回的已经不是引用了，(++myInt)运算后是一个临时数据，
临时数据再进行++操作，++的就不是myInt本体，而是另一个复制的临时数据(++myInt),
而此时再输出myInt，就只能是 1 而不是2 了，即后一个 ++ 没有作用到myInt本体身上。
如果想要像 原始的++ 操作一样，就需要返回引用。
返回引用就能保证：
第一次运算完的结果还是它本身，之后另一个++操作也是作用到它自身的。

2.后置++为什么要返回值

//后置++【return tmp】返回的是临时数据，临时数据在函数结束之后就被销毁了，临时数据返回引用的话会出现：
//第一次编译器会照顾一下给返回正确的值，第二次就直接出现问题了。
#include<iostream>
using namespace std;



class MyInteger
{

	friend ostream& operator<<(ostream& cout, const MyInteger& p1);
public:
	MyInteger() 
	{
		m_Num = 0;
	}
	//前置++重载
	MyInteger operator++()
	{
		this->m_Num++;
		return *this;
	}

	//后置++重载
	MyInteger operator++(int)//这就是占位参数的唯一用处
	{
		//先使用临时数据，保存一下目前的值
		MyInteger tmp = *this;
		m_Num++;
		return tmp;
	}

	int m_Num;
};


ostream& operator<<(ostream& cout, const MyInteger& myInt)
{
	cout << myInt.m_Num;
	return cout;
}


void test01()
{
	MyInteger myInt;
	//++myInt;//前置++ //error只要用的是编译器不认的运算符，都会报：没有与这些操作符匹配的 "某某" 运算符
	//++myInt;
	//myInt++;//后置++

	cout << ++(++myInt) << endl;//error只要用的是编译器不认的运算符，都会报：没有与这些操作符匹配的 "某某" 运算符
	cout << myInt << endl;
	cout << myInt++ << endl;//仅仅这样的话，这里会报错
}

int main()
{
	test01();
	int a = 10;

	++(++a);
	cout << a << endl;

	system("pause");
	return 0;
}