c++重载运算符

//

#include <iostream>
using namespace std;
class complex
{
public:
    complex() { real=imag=0; }
    complex(double r, double i)
    {
        real = r, imag = i;
    }
     complex operator +(const complex &c);
    complex operator -(const complex &c);
    complex operator *(const complex &c);
    complex operator /(const complex &c);
    friend void print(const complex &c);
private:
    double real, imag;
};
 inline complex complex:: operator +(const complex &c)
{
    return complex(real + c.real, imag + c.imag);
}

inline complex complex::operator -(const complex &c)
{
    return complex(real - c.real, imag - c.imag);
}

inline complex complex::operator *(const complex &c)
{
    return complex(real * c.real - imag * c.imag, real * c.imag + imag * c.real);
}

inline complex complex::operator /(const complex &c)
{
    return complex((real * c.real + imag + c.imag) / (c.real * c.real + c.imag * c.imag),
        (imag * c.real - real * c.imag) / (c.real * c.real + c.imag * c.imag));
}

void print(const complex &c)
{
    if(c.imag)
        cout<<c.real<<c.imag<<'i';
    else
        cout<<c.real<<'+'<<c.imag<<'i';
}

void main()
{
    complex c1(2.0, 3.0), c2(4.0, -2.0), c3;
    c3 = c1 + c2;
    cout<<"/nc1+c2=";
    print(c3);
    c3 = c1 - c2;
    cout<<"/nc1-c2=";
    print(c3);
    c3 = c1 * c2;
    cout<<"/nc1*c2=";
    print(c3);
    c3 = c1 / c2;
    cout<<"/nc1/c2=";
    print(c3);
    c3 = (c1+c2) * (c1-c2) * c2/c1;
    cout<<"/n(c1+c2)*(c1-c2)*c2/c1=";
    print(c3);
    cout<<endl;
}

//重载为成员函数

在程序中，类complex定义了4个成员函数作为运算符重载函数。将运算符重载函数说明为类的成员函数格式如下：

＜类名＞ operator ＜运算符＞(＜参数表＞)

其中，operator是定义运算符重载函数的关键字。

程序中出现的表达式：

    c1+c2

编译程序将给解释为：

  c1.operator+(c2)

其中，c1和c2是complex类的对象。operator+()是运算+的重载函数。

该运算符重载函数仅有一个参数c2。可见，当重载为成员函数时，双目运算符仅有一个参数。对单目运算符，重载为成员函数时，不能再显式说明参数。重载为成员函数时，总时隐含了一个参数，该参数是this指针。this指针是指向调用该成员函数对象的指针。

下面是友元函数运算符的

#include <iostream>
using namespace std;

class complex
{
public:
    complex() { real=imag=0; }
    complex(double r, double i)
    {
        real = r, imag = i;
    }
    friend complex operator +(const complex &c1, const complex &c2);
    friend complex operator -(const complex &c1, const complex &c2);
    friend complex operator *(const complex &c1, const complex &c2);
    friend complex operator /(const complex &c1, const complex &c2);
    friend
        void print(const complex &c);
private:
    double real, imag;
};

complex operator +(const complex &c1, const complex &c2)
{
    return complex(c1.real + c2.real, c1.imag + c2.imag);//使用对象
}

complex operator -(const complex &c1, const complex &c2)
{
    return complex(c1.real - c2.real, c1.imag - c2.imag);
}

complex operator *(const complex &c1, const complex &c2)
{
    return complex(c1.real * c2.real - c1.imag * c2.imag, c1.real * c2.imag + c1.imag * c2.real);
}

complex operator /(const complex &c1, const complex &c2)
{
    return complex((c1.real * c2.real + c1.imag * c2.imag) / (c2.real * c2.real + c2.imag * c2.imag),
        (c1.imag * c2.real - c1.real * c2.imag) / (c2.real * c2.real + c2.imag * c2.imag));
}

void print(const complex &c)
{
    if(c.imag)
        cout<<c.real<<c.imag<<'i';
    else
        cout<<c.real<<'+'<<c.imag<<'i';
}

void main()
{
    complex c1(2.0, 3.0), c2(4.0, -2.0), c3;
    c3 = c1 + c2;
    cout<<"/nc1+c2=";
    print(c3);
    c3 = c1 - c2;
    cout<<"/nc1-c2=";
    print(c3);
    c3 = c1 * c2;
    cout<<"/nc1*c2=";
    print(c3);
    c3 = c1 / c2;
    cout<<"/nc1/c2=";
    print(c3);
    c3 = (c1+c2) * (c1-c2) * c2/c1;
    cout<<"/n(c1+c2)*(c1-c2)*c2/c1=";
    print(c3);
    cout<<endl;
}

该程序的运行结果与上例相同。前面已讲过，对又目运算符，重载为成员函数时，仅一个参数，另一个被隐含；重载为友元函数时，有两个参数，没有隐含参数。因此，程序中出现的 c1+c2

编译程序解释为：

  operator+(c1, c2)

调用如下函数，进行求值，

  complex operator +(const coplex &c1, const complex &c2)

3. 两种重载形式的比较

一般说来，单目运算符最好被重载为成员；对双目运算符最好被重载为友元函数，双目运算符重载为友元函数比重载为成员函数更方便此，但是，有的双目运算符还是重载为成员函数为好，例如，赋值运算符。因为，它如果被重载为友元函数，将会出现与赋值语义不一致的地方

友元函数中需要有对象，所以友元函数一般为双目运算符