运算符重载

1)运算类：左右操作数都可以为左值或右值，表达式的值必须是右值。
友元：可以通过friend关键字，把一个函数或者类声明为一个类友元。被声明有关的函数或类可以自由访问授权类的任何私有成员。友元声明可以位于授权类的公有/私有/保护任何区域，其效果都一样。
2)赋值类：右操作数可为左值或右值，但左操作数必须是左值，表达式的值是左值且为左操作数本身（而非副本）。
3)输入输出：左操作数是ostream/istream，右操作数对于输出可以是左值也可以是右值，对于输入只能是左值，表达式的值是左操作数本身。

常用单双目运算符重载示例

class Complex {
public:
    Complex (int r = 0, int i = 0) :
        m_r (r), m_i (i) {}
    void show (void) const {
        cout << m_r << '+' << m_i << 'i' << endl;
    }
    // 第一个const：返回常对象，禁止对返回值赋值 == 返回右值
    // 第二个const：支持常对象形式的右操作数 == 形参不可修改,且支持右值,即使传左值也会隐式转换为const
    // 第三个const：支持常对象形式的左操作数 == 常对象调用
    //L.operator# (R) 成员类型的左调右参形式
    Complex const operator+ (Complex const& rhs) const 
    {
        return Complex (m_r + rhs.m_r, m_i + rhs.m_i);
    }
    Complex& operator+= (Complex const& rhs) 
    {
        m_r += rhs.m_r;
        m_i += rhs.m_i;
        return *this;
    }
    friend Complex& operator-= (Complex& lhs, Complex const& rhs) 
    {
        lhs.m_r -= rhs.m_r;
        lhs.m_i -= rhs.m_i;
        return lhs;
    }
    //const支持常对象（左操作数）调用，且返回右值
    Complex const operator- () const 
    {
        return Complex (-m_r, -m_i);
    }
    friend int operator~ (Complex const& opd) 
    {
        return sqrt (opd.m_r * opd.m_r + opd.m_i * opd.m_i);
    }
    friend istream& operator>> (istream& lhs, Complex& rhs) 
    {
        return lhs >> rhs.m_r >> rhs.m_i;
    }
    friend ostream& operator<< (ostream& lhs, Complex const& rhs) 
    {
        return lhs << rhs.m_r << '+' << rhs.m_i << 'i';
    }
    // 成员函数形式的前++
    Complex& operator++ (void) 
    {
        ++m_r;
        ++m_i;
        return *this;
    }
    // 全局函数形式的前--
    friend Complex& operator-- (Complex& opd) 
    {
        --opd.m_r;
        --opd.m_i;
        return opd;
    }
    // 成员函数形式的后++
    Complex const operator++ (int) 
    {
        Complex old = *this;
        ++*this;
        return old;
    }
    // 全局函数形式的后--
    friend Complex const operator-- (Complex& opd, int) 
    {
        Complex old = opd;
        --opd;
        return old;
    }

private:
    int m_r;
    int m_i;
    //声明为友元函数，用于支持访问Complex对象的私有成员。
    friend Complex const operator- (Complex const&, Complex const&);
};

//::operator# (L, R)全局的左一右二形式
Complex const operator- (Complex const& lhs, Complex const& rhs) 
{
    return Complex (lhs.m_r - rhs.m_r, lhs.m_i - rhs.m_i);
}

int main(void)
{
    Complex const a(1,2);
    Complex b(3,4);
    Complex c = a + b;//a.operator+(b);
    Complex d = b + a;//b.operator+(a);
    Complex e = b - a;

    Complex c1 (1, 2), c2 (3, 4)；
    c1 += c2; // c1.operator+= (c2)
    c1 -= c3;
    (c1 += c2) += c3;

    cout << -c1 << endl;
    cout << ~c2 << endl;

    cin >> c1 >> c2;
    cout << c1 << ' ' << c2 << endl;

    return 0;
}

[]和()的重载

#include <iostream>
using namespace std;
class A {
public:
    //下标运算符,非常属性调用者
    int& operator[] (int i) 
    {
        return m_array[i];
    }
    //下标运算符,常属性调用者
    int const& operator[] (int i) const 
    {
        //显示去常属性，隐式加常属性
        return const_cast<A&> (*this)[i];
    }
private:
    int m_array[10];
};
class B {
public:
    //函数运算符()
    int operator() (int x, int y) const 
    {
        return x + y;
    }
};
class Integer {
public:
    //类型转换运算符函数
    Integer (int i = 0) : m_i (i) {}
    operator int (void) const 
    {
        return m_i;
    }
    int m_i;
};
int main (void) {
    A a;
    a[0] = 1; // a.operator[] (0) = 1
    a[1] = 2; // a.operator[] (1) = 2
    cout << a[0] << ' ' << a[1] << endl;
    A const& cr = a;
    cout << cr[0] << endl;
//  cr[0]++;
    B b;
    cout << b (123, 456) << endl;
//  cout << b.operator() (123, 456) << endl;
    Integer x;
    x = 123;
    cout << x.m_i << endl;
    int y;
    y = x;
    cout << y << endl;
    return 0;
}