C++编程思想学习笔记---第12章 运算符重载

运算符重载只是一种语法上的方便，只是另一种形式的函数调用。
应当说明，运算符重载不应该被滥用，只有在能使涉及类的代码更易写，特别是更易读时，才有理由重载运算符

12.1　运算符重载的语法：

#include <iostream>
using namespace std;

class Integer{
    int i;
public:
    Integer(int ii): i(ii) {}
    const Integer operator+(const Integer& rv) const
    {
        cout << "operator+" << endl;
        return Integer(i + rv.i);
    }
    Integer& operator+=(const Integer& rv)
    {
        cout << "operator+=" << endl;
        i += rv.i;
        return *this;
    }
    int GetValue() const
    {
        return i;
    }
};

int main()
{
    cout << "built-in types:" << endl;
    int i = 1;
    int j = 2;
    int k = 3;
    k += i + j;
    cout << "k = " << k << endl;
    cout << "user-defined types:" << endl;
    Integer ii(1), jj(2), kk(3);
    kk = ii + jj;
    cout << "Int.kk = " << kk.GetValue() << endl;
    kk += ii;
    cout << "Int.kk = " << kk.GetValue() << endl;
    return 0;
}

对于二元运算符，唯一的参数是出现运算符右侧的那个操作数，运算符左边的操作数是调用该重载后的运算符的对象。

12.2　可重载的运算符

几乎所有c中的运算符都可以重载，但其行为时很受限制的。特别是不能使用c中没有意义的运算符（例如用**代表求幂），不能改变运算符的优先级，不能改变运算符的参数个数

12.2.1　一元运算符

#include <iostream>
using namespace std;

class Integer{
    long i;
    Integer* This() { return this; }
public:
    Integer(long ll = 0): i(ll) {}
    friend const Integer&
        operator+(const Integer& a);
    friend const Integer
        operator-(const Integer& a);
    friend const Integer
        operator~(const Integer& a);
    friend Integer*
        operator&(Integer& a);
    friend int
        operator!(const Integer& a);
    friend const Integer&
        operator++(Integer& a);
    friend const Integer
        operator++(Integer& a, int);
    friend const Integer&
        operator--(Integer& a);
    friend const Integer
        operator--(Integer& a, int);
};

const Integer& operator+(const Integer& a)
{
    cout << "+Integer\n";
    return a;
}

const Integer operator-(const Integer& a)
{
    cout << "-Integer\n";
    return Integer(-a.i);
}

const Integer operator~(const Integer& a)
{
    cout << "~Integer\n";
    return Integer(~a.i);
}

Integer* operator&(Integer& a)
{
    cout << "&Integer\n";
    return a.This();// This() is a private function, can be called? dubious...
}

int operator!(const Integer& a)
{
    cout << "!Integer\n";
    return !a.i;
}

const Integer& operator++(Integer& a)
{
    cout << "++Integer\n";
    a.i++;
    return a;
}

const Integer operator++(Integer& a, int)
{
    cout << "Integer++\n";
    Integer before(a.i);
    a.i++;
    return before;
}

const Integer& operator--(Integer& a)
{
    cout << "--Integer\n";
    a.i--;
    return a;
}

const Integer operator--(Integer& a, int)
{
    cout << "Integer--\n";
    Integer before(a.i);
    a.i--;
    return before;
}

void f(Integer a)
{
    +a;
    -a;
    ~a;
    Integer *ip = &a;
    !a;
    ++a;
    a++;
    --a;
    a--;
}

int main(void)
{
    Integer a;
    f(a);

    return 0;
}

打印的内容为：
+Integer
-Integer
~Integer
&Integer
!Integer
++Integer
Integer++
–Integer
Integer–
这里容易产生混淆的运算符是自增和自减运算符。实际操作的结果是：
++a : 调用operator++(a)
a++ : 调用operaotr++(a, int)
自减运算符也是如此。

12.2.2　二元运算符

（代码太长，请参阅原书）
operator=只允许作为成员函数，而且在写=时应该小心类型的转换等。

12.2.3　参数和返回值

（待续）