运算符重载

42 阅读 0 评论 28 点赞

我是靠谱客的博主美好帽子，最近开发中收集的这篇文章主要介绍运算符重载，觉得挺不错的，现在分享给大家，希望可以做个参考。

概述

运算符重载：
是指对已有的运算符赋予多重含义，使同一个运算符作用于不同类型的数据时导致不同的行为，运算符重载实质上就是函数重载，重载为成员函数，可以自由的访问本类的数据成员。
规则：
（1）只能重载已有运算符，不能创造新的运算符；
（2） “.”，“*”，“::”，“ ? : ”不能重载；
（3） “ = ”，“[]”，“->”，“()”，只能以成员形式重载；
（4）重载运算符时，若其所有操作数为内置类型，则不能重载；
（5）重载运算符不会改变运算符三特性
（6）单目运算符：
a．成员形式：无参，唯一操作数传给this；
b．普通形式：单参，唯一操作数传给参数；
双目运算符：
a．成员形式：单参，左操作数传给this，右操作数传给参数；
b．普通形式：双参：左操作数传给第一个参数，右操作数传给第二个参数；
（7）*：重载运算符尽可能保证所做操作与原运算符功能一致或相近。

例：

class Magic
{
	double x;
public:
	Magic(double d=0.00):x(fabs(d)){}
	Magic operator+(Magic c) { return Magic(sqrt(x*x + c.x *c.x)); }
	friend ostream& operator<<(ostream& os, Magic c) { return os << c.x; }
};
void main1()
{
	Magic ma;
	cout << ma << ',' << Magic(-8) << ',' << ma + Magic(-3) + Magic(-4);
}

定义了Magic类，并对其无名对象和输出进行重载。值得注意的是：
ostream是output stream的简称，即输出流。
在C++中用来输出。
一个典型的输出流对象就是在C++中标准输出流cout。
在C++中，很少自定义ostream的对象，更多的是直接使用cout。
ostream这个类型，往往出现在<<操作重载中，作为某个类的友元函数出现。

课堂例子：定义了USD类和CNY类，并在CNY类中重载了“+”，“++”(前置)，“++”(后置)，“()”，“<<”等运算符。

 class USD
    {
    protected:
    	int _y;
    	int _f;
    public:
    	explicit USD(double v = 0.0)
    		:_y(static_cast<int>(v)), _f(static_cast<int>((v - _y) * 100 + 0.5))
    	{}
	void Show()const
	{
		cout << "$" << _y << "." <<
			setw(2) << setfill('0') << _f << endl;
	}
};

class CNY
{
protected:
	int _y;
	int _f;
public:
	explicit CNY(double v=0.0)
		:_y(static_cast<int>(v)), _f(static_cast<int>((v-_y)*100 + 0.5))
	{}

	void Show()const
	{
		cout << "￥" << _y << "." << 
			setw(2) << setfill('0') << _f << endl;
	}

	CNY operator+(const CNY& ref)const
	{
		CNY ret(this->_y + ref._y + (this->_f + ref._f) / 100.0);
		return ret;
	}

	CNY& operator++()
	{
		_y += 1;
		return *this;
	}

	const CNY operator++(int e)
	{
		CNY t(*this);
		_y += 1;
		return t;
	
	}

	CNY& operator=(const CNY& ref)
	{
		this->_y = ref._y;
		this->_f = ref._f;

		cout << "haha" << endl;

		return *this;
	}

	operator USD()
	{
		return USD((this->_y + this->_f/100.0)*0.1491);
	}

	friend ostream& operator<<(ostream& os, const CNY& ref);//重载<<运算符，声明为友元
};
CNY operator+(const CNY& c1, const CNY& c2)
{
	CNY ret(100.0);
	CNY ret(c1._y + c2._y + (c1._f + c2._f) / 100.0);
	return ret;
}

ostream& operator<<(ostream& os, const CNY& ref)
{
	os << "￥" << ref._y << "." <<
		setw(2) << setfill('0') << ref._f;
	return os;
}

int operator+(const int& a, const int& b)
{
	return a + b + 1;
}

int main()
{
	CNY c1(10.5), c2(7.45), c3(2.22), c4;
	USD u(3.45);
	c4 = Add(c1, Add(c2, c3));

	c4 = c1.Add(c2.Add(c3));

	c4 = c1++ + c2;
	c1 = c2;

	CNY* p = &c1;
	const CNY * q = &c1;
	c1.Show();

	cout << c1 << endl;

	USD u;

	u = (USD)c1;
	u.Show();

	int i = 9, j = 3, k=5;

	(i = j) = k;

	(i += j) += k;
	cout << i << endl;
 	cout << j << endl;

	return 0;
}