c++中的运算符重载和衍生的思想

运算符重载的概念我们并不陌生，指的是一个运算符在不同环境下有不同的含义。在c语言中就有运算符重载了，只不过不能程序员自定义而已。例如 * 在两个数字之间时意味着乘号，在一个地址的左边时意味着解引用。

在c++中引入了类和对象，使程序变得更加复杂。为了阅读程序方面，简化按键次数，c++可以自定义运算符重载了。

c++一般对类设置运算符重载，使自定义类型满足和内置类型相同的逻辑。比如设计一个复数类，它可以像整型一样"±*/"等做运算，比调用函数更容易被人理解。

运算符重载可以重载单目和双目运算符，不能重载三目运算符。举些例子如下：

重载+：让类可以±*/，使用起来更方便

class Test
{
public:
	Test(int ma = 0, int mb = 0):ma(ma),mb(mb){}
	Test operator+(Test& rhs)
	{
		return Test(ma+rhs.ma, mb+rhs.mb);
	}
private:
	int ma;
	int mb;
};

重载()：把对象当作函数用，成为函数对象或仿函数，STL中有，用作模式的指定，可以和泛型算法结合用，比如排序时指定是升序还是降序。

template <typename T>
class greater
{
public:
	bool operator()(const T& t1, const T& t2) const
	{
		return t1 > t2;
	}
};
int main()
{
int main()
{
	greater<int> compare;
	int a,b;
	cout << compare(a, b) << endl;
}

重载[]：不同的类对于重载[]有不同的含义，比如vector和string中的[]让人能像访问数组一样通过下标访问元素。set中通过object[key] = value来向集合中添加pair。

template <typename T>
class Test
{
public:
	Test(int size = 1)
	{
		data = new T[size]();
	}
	~Test()
	{
		delete[] data;
		data = NULL;
	}
	T& operator[](int subscript)
	{
		return data[subscript];
	}
private:
	T *data;
};
int main()
{
	Test<int> tt(10);
	cout << tt[2] << endl;
}

重载<<：输出流的第一个对象不是类自身，因此要在类外实现。因为实现中在类外访问了类中的私有成员，因此要在类中添加友元。

class Test
{
public:
	friend ostream& operator<<(ostream&, Test&);
	Test(int ma, int mb):ma(ma),mb(mb){}
private:
	int ma;
	int mb;
};
ostream& operator<<(ostream& output, Test& rhs)
{
	output << rhs.ma << "|" << rhs.mb;
	return output;
}
int main()
{
	Test t(1,2);
	cout << t << endl;
}

重载*解引用：让人能像使用指针一样使用对象，其中ptr叫做指向对象的指针。c++中智能指针就是基于这个思想，让程序员只管new，清栈时自动调用智能指针的析构函数完成delete，防止了内存泄漏。STL中的迭代器也有一点这个思想，迭代器指向容器，实现统一的遍历方式。

class tteesstt
{
public:
	void show()
	{
		cout << "hello" << endl;
	}
};
class Test
{
public:
	Test(tteesstt *p):ptr(p){}
	~Test()
	{
		delete ptr;
		ptr = NULL;
	}
	tteesstt& operator*()
	{
		return *ptr;
	}
private:
	tteesstt *ptr;
};
int main()
{
	Test t = new tteesstt();
	(*t).show();
}

重载类型：相当于给自定义类型提供了一个强制转化方式。

class Test
{
public:
	operator char()
	{
		return '6';
	}
};
int main()
{
	Test t;
	//相当于cout << (char)t << endl;
	cout << t << endl;
}

重载++：前置和后置++都是单目运算符，写法上完全一样。为了区分，规定后置++的()里加一个占位符来声明。

class Test
{
public:
	Test():data(0){}
	~Test(){}
	//后置++
	int operator++(int)
	{
		int tmp = data;
		data += 1;
		return tmp;
	}
	//前置++
	int& operator++()
	{
		data += 1;
		return data;
	}
private:
	int data;
};

总结：c++的运算符重载丰富多样，从中产生的很多思想尤其是STL，值得我们学习和思考。