a + b;        // 等價(jià)于 a.operator+(b) 或 operator+(a, b)
a == b;       // 等價(jià)于 a.operator==(b) 或 operator==(a, b)

// 使用運(yùn)算符重載
list1 + list2;

// 不使用運(yùn)算符重載
list1.concat(list2);

Complex operator+(Complex& a, Complex& b)
{
    Complex ret;
    ret.real = a.real + b.real;
    ret.image = a.image + b.image;
    return ret;
}

class Complex {
public:
    Complex operator+(const Complex& other) {
        Complex ret;
        ret.real = this->real + other.real;
        ret.image = this->image + other.image;
        return ret;
    }
};

class Complex {
    friend Complex operator+(const Complex& a, const Complex& b);
    // ...
};

Complex operator-(Complex& a, Complex& b)
{
    Complex ret;
    ret.real = a.real - b.real;
    ret.image = a.image - b.image;
    return ret;
}

ostream& operator<<(ostream& cout, Complex& other)
{
    cout << other.real << "+" << other.image << "i";
    return cout;
}

ostream& operator<<(ostream& cout, const Complex& other);

Complex& operator++()//前置++
{
    this->real += 1;
    return *this;
}

Complex operator++(int)//后置++
{
    Complex a = *this;//保存原始值
    this->real += 1;
    return a;//返回原始值
}

Jeff& operator=(Jeff &a)
{
    if (age)
    {
        delete age;
        age = NULL;
    }
    age = new int;//分配新內(nèi)存
    *age = *a.age;
    return *this;
}

Jeff& operator=(const Jeff &a)
{
    if (this != &a) { // 自賦值檢查
        if (age) {
            delete age;
        }
        age = new int(*a.age);
    }
    return *this;
}

bool operator==(const Point& a)const
{
    return this->x == a.x && this->y == a.y;
}

bool operator<(const Point& a)const
{
    int c = x * x + y * y;
    int d = a.x * a.x + a.y * a.y;
    return c < d;
}

int operator()(int a, int b)
{
    data++;
    return a + b + data;
}

#include<iostream>
using namespace std;
#include<string>


int main()
{
	//1.加法運(yùn)算符
	int a = 520;
	int b = 1314;
	cout << a + b<<endl;
	//2.字符串拼接
	string c = "520";
	string d = "1314";
	cout << c + d << endl;

}
復(fù)數(shù)類(lèi)：
class Complex
{
	friend ostream& operator<<(ostream& cout, Complex& other);
	friend Complex operator+(Complex& a, Complex& b);
	friend Complex operator-(Complex& a, Complex& b);
public:
	Complex() :real(0), image(0)
	{

	}
	Complex (int real, int image)
	{
		this->real = real;
		this->image = image;
	}
	//Complex operator+(Complex& other)//加了operator后可以進(jìn)行a+b操作，這個(gè)是成員函數(shù)形式
	//{
	//	Complex ret;
	//	ret.real = this->real + other.real;//this是指針用->表示，other是引用對(duì)象用.表示
	//	ret.image = this->image + other.image;
	//	return ret;
	//}
	void print()
	{

		cout << real << "+" << image<<"i" << endl;//cout傳進(jìn)來(lái)了
	}
private:
	int real;
	int image;
};
Complex operator+(Complex& a,Complex&b)//加了operator后可以進(jìn)行a+b操作,全員函數(shù)重載+改-就變-了
{
	Complex ret;
	ret.real = a.real+b.real;//this是指針用->表示，other是引用對(duì)象用.表示
	ret.image = a.image+b.image;
	return ret;
}
Complex operator-(Complex& a, Complex& b)//加了operator后可以進(jìn)行a+b操作,全員函數(shù)重載+改-就變-了
{
	Complex ret;
	ret.real = a.real - b.real;//this是指針用->表示，other是引用對(duì)象用.表示
	ret.image = a.image - b.image;
	return ret;
}
//void operator<<(ostream& cout, Complex& other)//void 不行
//{
//	cout << other.real << "+" << other.image<<"i" << endl;
//}
ostream& operator<<(ostream& cout, Complex& other)//我左移后需要不斷的輸出所以要返回ostream可以繼續(xù)加，實(shí)現(xiàn)鏈?zhǔn)捷敵觯。。?
{
	cout << other.real << "+" << other.image << "i";
	return cout;
}//補(bǔ)充知識(shí)點(diǎn)為什么ostream要加&，因?yàn)閏out是ostream類(lèi)型的函數(shù)，全局只有一個(gè)并且不希望外部調(diào)用也不希望內(nèi)部調(diào)用，調(diào)用的話會(huì)自動(dòng)刪除！??！可以用f12看拷貝那一塊的源碼
//去掉&后會(huì)自動(dòng)調(diào)用拷貝函數(shù)，然后拷貝函數(shù)就會(huì)被刪除就無(wú)法調(diào)用了?。?！
int main()
{
	Complex a(10,20);
	Complex b(5,8);
	Complex c = a + b; //a.add(b);
	Complex d = a - b;
	//c.print();
	//d.print();
	////左移函數(shù)重載

	cout << c << endl;//因?yàn)樽笠坪瘮?shù)沒(méi)有返回值void類(lèi)型，我們要返回ostream這個(gè)類(lèi)型才可以繼續(xù)進(jìn)行返回操作
	return 0;

}


函數(shù)的遞增

class Complex
{
	friend ostream& operator<<(ostream& cout, const Complex &other);//Complex other每次都會(huì)走拷貝構(gòu)造，已知這個(gè)不能修改，我們加一個(gè)&就可以避免拷貝構(gòu)造了
	friend Complex operator+(Complex& a, Complex& b);
	friend Complex operator-(Complex& a, Complex& b);

private:
	int real;
	int image;

public:
	Complex() :real(0), image(0)
	{

	}
	Complex(int real, int image)
	{
		this->real = real;
		this->image = image;
	}
Complex& operator++()//前置++，不加引用就會(huì)生成新的對(duì)象，加了之后就是指向自己的
	{
		this->real += 1;
		return *this ;
	}
Complex operator++(int)//后置++，加引用就會(huì)返回臨時(shí)的變量但是我，不想要這個(gè)臨時(shí)的我要本身的，所以不加&讓編譯器自己生成一個(gè)拷貝函數(shù)
{
	Complex a = *this;//等于對(duì)象本身，臨時(shí)的變量會(huì)被析構(gòu)掉所以會(huì)返回隨機(jī)值
	this->real += 1;
	return a;//返回原來(lái)的對(duì)象
}
};
ostream& operator<<(ostream& c,const Complex& a)
{
	cout << a.real << "+" << a.image << "i";
	return c;
}

int main()
{
	int x = 1;
	cout << ++x<<endl;
	cout << ++x<<endl;

	Complex a(10, 20);
	/*++a;*/
	//cout << ++a << endl;
	//cout << ++(++a) << endl;
	//cout << a << endl;//第一++成功了，再調(diào)用一次就會(huì)生成新的對(duì)象與原來(lái)的a沒(méi)有關(guān)系了所以要加引用確定原本對(duì)象；
	cout << a++ << endl;
	cout << (a++)++ << endl;
	cout << a << endl;//加了&后這邊就會(huì)報(bào)錯(cuò)為什么因?yàn)閍的返回值是一個(gè)可修改的左值，所以我們可以用const去修飾這個(gè)返回值，這樣就可以避免這樣的事情發(fā)生，這樣也是規(guī)范的寫(xiě)法



}
賦值重載運(yùn)算
class Jeff
{
	
public:
	Jeff():age(NULL)
	{
		
	};
	Jeff(int age)
	{
		this->age = new int;
		*(this->age) = age;
	}
int *age;
~Jeff()
{
	if (age != NULL)
	{
		delete age;
age = NULL;
	}
	
}
Jeff& operator=(Jeff &a)
{
	if (age)
	{
		delete age;
		age = NULL;
	}
	age = new int;//新的內(nèi)存，析構(gòu)不會(huì)析構(gòu)到這一快
	*age = *a.age;
	return *this;
}



};
int main()
{

	Jeff a(1);
	Jeff b(2);
	cout << *(a.age) << endl;//內(nèi)存泄漏
	cout << *(b.age) << endl;
	a = b;//a b兩個(gè)對(duì)象本來(lái)有那個(gè)內(nèi)存的，第一次a調(diào)用時(shí)析構(gòu)函數(shù)把a(bǔ)的對(duì)象銷(xiāo)毀了，第二次b調(diào)用時(shí)由于兩個(gè)都指向同一塊地址，b調(diào)用完成后又一次析構(gòu)，這時(shí)就造成二次析構(gòu)了

	cout << *(a.age) << endl;
	cout << *(b.age) << endl;
	Jeff c(3);
	a = b = c;


	return 0;
}

關(guān)系運(yùn)算符重載
class Point
{
	int x, y;
public:
	Point():x(0), y(0)
	{

	};
	Point(int x, int y)
	{
		this->x = x;
		this->y = y;
	}
	bool operator==(const Point& a)const
	{
		return this->x == a.x && this->y == a.y;
	  }
	bool operator<(const Point& a)const
	{
		int c = x * x + y * y;
		int d = a.x * a.x + a.y * a.y;
		return c < d;

	}

	bool operator>(const Point& a)const
	{
		if (*this==a)
		{
			return false;
		}
		else if (*this < a)
		{
			return false;
		}
		else {
			return true;
		}
	}
};
int main()
{
	Point a(2,6);
	Point b(1,8);
	if (a > b)
	{
		cout << "a到原點(diǎn)的距離大于b" << endl;
	}
	else if (a == b)
	{
		cout << "a到原點(diǎn)的距離等于b" << endl;
	}
	else {
		cout << "a到原點(diǎn)的距離小于b" << endl;
	}

	return 0;

}
 


函數(shù)調(diào)用運(yùn)算符重載
class HJM
{
private:
	int data;
public:
	HJM() :data(0)
	{

	};
	int operator()(int a, int b)
	{
		data++;
		return a + b + data;
	};//仿函數(shù)調(diào)用可以記錄當(dāng)前的狀態(tài)
	
};
int Add(int a, int b)
	{
		return a + b;
	}
int main()
{
	HJM add;
	cout << add(10, 5) << endl;
	cout << add(10, 5) << endl;
	cout << add(10, 5) << endl;
	cout << add(10, 5) << endl;
	cout << add(10, 5) << endl;
	cout << add(10, 5) << endl;
	cout << add(10, 5) << endl;
	cout << Add(10, 5)<< endl;
	cout << Add(10, 5) << endl;
	cout << Add(10, 5) << endl;
	cout << Add(10, 5) << endl;
	cout << Add(10, 5) << endl;
	return 0;
}