c++运算符重载（复数类为例）

我们所知道的运算符有很多，基本上概括了所有的数据，之所以说基本上，还有特殊的情况，我们所知道的运算符并不能直接的进行处理。

今天就拿复数的运算作为例子。

要运算两个数的和，很简单的a+b，我们使用了“+”，这个问题在我们学习复数之前一直都是直接进行的。不过，我们知道复数有实部和虚部，两个复数相加的时候，需要分开，实部相加，虚部相加，虽然看着也很简单，但是它不是一步完成的。

这个时候我们就引入一个新的概念，运算符重载：就是对已有的运算符重新进行定义，赋予其另一种功能，以适应不同的数据类型。

要实现复数的相加，我们需要对“+”，进行运算符重载，也就是说，我们需要自己编写程序说明“+”在作用于complex类时，需要实现什么功能。

运算符重载规则如下：
①、 C++中的运算符除了少数几个之外，全部可以重载，而且只能重载C++中已有的运算符。

②、 重载之后运算符的优先级和结合性都不会改变。

③、 运算符重载是针对新类型数据的实际需要，对原有运算符进行适当的改造。一般来说，重载的功能应当与原有功能相类似，不能改变原运算符的操作对象个数，同时至少要有一个操作对象是自定义类型。

不能重载的运算符只有五个，它们是：
成员运算符“.”、指针运算符“*”、作用域运算符“：：”、“sizeof”、条件运算符“？：”。

运算符重载形式有两种，重载为类的成员函数和重载为类的友元函数。

1、运算符重载为类的成员函数的一般语法形式为：

函数类型 operator 运算符（形参表） 
{ 
  函数体； 
} 

2、运算符重载为类的友元函数的一般语法形式为：

friend 函数类型 operator 运算符（形参表） 
{ 
  函数体； 
} 

其中，函数类型就是运算结果类型；operator是定义运算符重载函数的关键字；运算符是重载的运算符名称（如：+）。

那么什么时候该重载为成员函数，什么时候该重载为友元函数呢？

为类设计重载操作符的时候，必须选择是将操作符设置为 类成员还是友元函数。在某些情况下，程序员没有选择， 操作符必须是成员；在另一些情况下，有些经验原则可指导我们做出决定。

遵循下列原则：

赋值（=）、下标（[]）、调用（()）和成员访问箭头（->）等操作符必须定义为成员，将这些操作符定义为非成员函数将在编译时标记为错误。
像赋值一样，复合赋值操作符通常应定义为类的成员函数，与赋值不同的是，不一定非得这样做，如果定义非成员复合赋值操作符，不会出现编译错误。
改变对象状态或与给定类型紧密联系的其他一些操作符， 如自增、自减和解引用，通常就定义为类成员。
对称的操作符，如算术操作符、相等操作符、关系操作 符最好定义为友元函数。>>
<<操作符定义为友元函数。

复数类的实现：

#include<iostream>
#include<math.h>
using namespace std;

class Complex{
public:
    Complex(double dReal,double dImage)
    {
        _dReal = dReal;
        _dImage = dImage;
    }
    Complex(const Complex & c)
    {
        _dReal = c._dReal;
        _dImage = c._dImage;
    }
    ~Complex()
    {
        _dReal = 0;
        _dImage = 0;
    }
    /*Complex &operator=(Complex &c)
    {
        return *this;
    }*/
    Complex operator+(const Complex &c)
    {
        Complex temp = *this;
        temp._dReal += c._dReal;
        temp._dImage += c._dImage;
        return temp;
    }
    Complex operator-(const Complex &c)
    {
        Complex temp = *this;
        temp._dReal -= c._dReal;
        temp._dImage -= c._dImage;
        return temp;
    }
    Complex operator*(const Complex &c)//乘法运算符重载，区别于加减法
    {
        Complex temp1 = *this;
        double temp = _dReal;
        temp1._dReal = (_dReal* c._dReal) - (_dImage* c._dImage);
        temp1._dImage = (temp*c._dImage) + (_dImage*c._dReal);
        return temp1;
    }
    Complex operator/(const Complex &c)
    {
        Complex temp = *this;
        double temp1 = c._dReal*c._dReal + c._dImage*c._dImage;
        double temp2 = _dReal;
        temp._dReal = ((_dReal* c._dReal) + (_dImage* c._dImage))/temp1;
        temp._dImage = (-(temp2*c._dImage) + (_dImage*c._dReal))/temp1;
        return temp;
    }

    double Modulo(Complex&c)//求模
    {
        double temp = 0;
        temp = sqrt(c._dReal*c._dReal + c._dImage*c._dImage);
        return temp;
    }

    //Complex operator+=(const Complex &c);
    //Complex operator-=(const Complex &c);
    //Complex operator*=(const Complex &c);
    //Complex operator/=(const Complex &c);

    //bool operator>(const Complex &c);
    //bool operator>=(const Complex &c);
    //bool operator<(const Complex &c);
    //bool operator<=(const Complex &c);
    //bool operator==(const Complex &c);
    //bool operator!=(const Complex &c);

    friend ostream & operator<<(ostream&os, Complex &c)
    {
        if (c._dImage == 0)
        {
            cout << c._dReal ;
        }
        cout << c._dReal << "+"<< c._dImage <<"i";
        return os;
    }

private:
    double _dReal;
    double _dImage;
};

//inline Complex Complex:: operator+(const Complex&c)
//{
//  return Complex(_dReal + c._dReal, _dImage + c._dImage);
//}

int main()
{
    Complex c1(2, 3);
    //Complex c2(c1);
    Complex c2(1, 1);
    Complex c3(0,0);//加法测试
    c3 =( c1 + c2);
    cout << "c3=" << c3 << endl;

    Complex c4(0, 0);//减法测试
    c4 = (c3 - c1);
    cout << "c4=" << c4 << endl;

    Complex c5(0, 0);//乘法测试
    c5 = (c4*c2);
    cout << "c5=" << c5 << endl;

    Complex c6(0, 0);//除法测试
    c6 = (c5 / c4);
    cout << "c6=" << c6 << endl;

    cout << "c1的模为" << c1.Modulo(c1)<<endl;//模的成员函数测试
    cout << "c5的模为" << c5.Modulo(c5) << endl;

    system("pause");
    return 0;
}