编译期多态之操作符重载

#include<iostream>
using namespace std;

enum type{ A, B };

class Complex
{
public:
	friend ostream &operator<<(ostream &os, const Complex &c);

	Complex(int real = 0, int virt = 0)
		:real(real), virt(virt)
	{
		cout << "Complex(int, int )" << endl;
	}
	~Complex()
	{
		cout << "~Complex()" << endl;
	}
	void out()
	{
		cout << real << "+" << virt << "i" << endl;
	}

	// 函数对象
	void operator()(void)
	{
	}
	
	//c1+c2--->c1.operator+(c2);
	Complex operator+(const Complex &c)
	{
		//	real+c.real;
		//	virt+c.virt;
		cout << "operator+" << endl;
		Complex retC(real + c.real, virt + c.virt);
		return retC;
	}

	//c1-c2--->c1.operator-(c2);
	Complex operator-(const Complex &c)
	{
		cout << "operator-" << endl;
		Complex tmp;
		tmp.real = real - c.real;
		tmp.virt = virt - c.virt;
		return tmp;
	}

	//c1=c2--->c1.operator=(c2);
	Complex &operator=(const Complex &c)
	{
		cout << "operator=" << endl;
		real = c.real;
		virt = c.virt;
		return *this;
	}

	//c1+=c2--->c1.operator+=(c2);
	Complex &operator+=(const Complex &c)
	{
		cout << "operator+=" << endl;
		real += c.real;
		virt += c.virt;
		return *this;
	}

	//c1+100--->c1.operator+(val);
	Complex operator+(const int &val)
	{
		cout << "operator+100" << endl;
		return Complex(real + val, virt + val);
	}

	//c1[a] real--->c1.operator[](ch);
	//c1[b] virt--->c1.operator[](ch);
	int operator[](const char ch)
	{
		cout << "operator[]" << endl;
		if (ch == 'a')
			return real;
		if (ch == 'b')
			return virt;
	}

	int operator[](const enum type &t)
	{
		if (t == A)
			return real;
		if (t == B)
			return virt;
	}


	//前++（无参），++c1 ===>c1.operator++();
	Complex operator++()
	{
		cout << "++x" << endl;
		real++;
		virt++;

		//return Complex(real+1, virt+1);
		return *this;
	}
	//后++（有参）,c1++ ===>c1.operator++();
	Complex operator++(int)
	{
		cout << "x++" << endl;
		Complex tmp(real, virt);
		real++;
		virt++;
		return tmp;
	}

	//c1<<6 ===>c1.operator(int)

	//c1<<c2
	Complex &operator<<(const Complex &c)
	{
		real = c.real;
		virt = c.virt;
		return *this;
	}

	//c1>>c2
	Complex &operator>>(Complex &c)
	{
		c.real = real;
		c.virt = virt;
		return c;
	}
private:
	int real;
	int virt;
};

//c++不支持重载三目运算符，比如?和, 

ostream &operator<<(ostream &os, const Complex &c)
{
	cout << "ostream<<Complex" << endl;
	//(a+bi)
	os << "(" << c.real << "+" << c.virt << "i)" << endl;
	return os;
}

void main()
{
	Complex c1(1, 2);
	Complex c2(3, 4);
	c1.out();

	//c1.operator+(c2).out();
	(c1 + c2).out();
	(c1 - c2).out();

	(c1 = c2).out();

	Complex c3(5, 6);
	((c1 = c2) = c3).out();
	(c1 += c3).out();

	(c1 + 100).out();

	cout << "c1[a]:" << c1['a'] << endl;
	cout << "c2[b]:" << c2['b'] << endl;

	cout << "c1[a]: " << c1[A] << endl;
	cout << "c1[b]: " << c2[B] << endl;

	Complex c4(0, 0);
	(c4++).out();
	c4.out();

	Complex c5(0, 0);
	(++c5).out();


	c3 >> c4;
	c4.out();
	c5 << c3;
	c5.out();

	//cout.operator<<(c5);
	cout << (c5 << c1);

}