Think_in_CPP第十二章 操作符重载(1)

12.1 重载方式

操作符有两种重载方式：成员函数和全局函数。以Integer类来说明这两种方式。

12.1.1 全局函数方式

class Integer {
long i;
Integer* This() { return this; }
public:
Integer(long ll = 0) : i(ll) {}
// No side effects takes const& argument:
friend const Integer&
operator+(const Integer& a);
}

const Integer& operator+(const Integer& a) {
cout << "+Integer\n";
return a; // Unary + has no effect
}

12.1.2 成员函数方式

class Integer {
long i;
Integer* This() { return this; }
public:
Integer(long ll = 0) : i(ll) {}
// No side effects takes const& argument:
const Integer& operator+() const{
cout << "+Integer\n";
return *this;
};
}

12.2 一元操作符(Unary operators)
12.2.1 全局函数重载方式

class Integer {
long i;
Integer* This() { return this; }
public:
Integer(long ll = 0) : i(ll) {}
// No side effects takes const& argument:
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);
// Side effects have non-const& argument:
// Prefix:
friend const Integer&  operator++(Integer&  a);
// Postfix:
friend const Integer  operator++(Integer&  a, int);
// Prefix:
friend const Integer& operator--(Integer&  a);
// Postfix:
friend const Integer  operator--(Integer&  a, int);
};
// Global operators:
const Integer& operator+(const Integer& a) {
cout << "+Integer\n";
return a; // Unary + has no effect
}

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(); // &a is recursive!
}

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

// Prefix; return incremented value
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;
}

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

// Postfix; return the value before decrement:
const Integer operator--(Integer& a, int) {
cout << "Integer--\n";
Integer before(a.i);
a.i--;
return before;
}

12.2.2 成员函数重载方式

class Byte {
unsigned char b;
public:
Byte(unsigned char bb = 0) : b(bb) {}
// No side effects: const member function:
const Byte& operator+() const {
cout << "+Byte\n";
return *this;
}
const Byte operator-() const {
cout << "-Byte\n";
return Byte(-b);
}
const Byte operator~() const {
cout << "~Byte\n";
return Byte(~b);
}
Byte operator!() const {
cout << "!Byte\n";
return Byte(!b);
}
Byte* operator&() {
cout << "&Byte\n";
return this;
}
// Side effects: non-const member function:
const Byte& operator++() { // Prefix
cout << "++Byte\n";
b++;
return *this;
}
const Byte operator++(int) { // Postfix
cout << "Byte++\n";
Byte before(b);
b++;
return before;
}
const Byte& operator--() { // Prefix
cout << "--Byte\n";
--b;
return *this;
}
const Byte operator--(int) { // Postfix
cout << "Byte--\n";
Byte before(b);
--b;
return before;
}

12.2.3关于++和--的前置和后置使用
为了区别前置和后置这两种情况，对于后者重载函数，在声明时多加一个int参数，这个参数只是为了和前置版本进行区别，在实际的函数调用中不使用。