C++之运算符重载

在C语言和C++中，一般的运算符只能对基本类型数据进行操作，而不支持用户自定义类型，比如下面：

#include <iostream>
using namespace std;
class Int
{
public:
    Int(int i = 0):m_i = i
    {}
    ~Int()
    {}
private:
    int m_i;
}
int main()
{
    Int S1(2);
    Int S2(1);
    S2 = S2 + S1;
    cout << "S2 = " << S2 << endl;

在上述程序段中，执行完成后出现erro:
[root@localhost Desktop]# g++ test.cpp
test.cpp:13:1: error: expected ‘;’ after class definition
}
^
test.cpp: In constructor ‘Int::Int(int)’:
test.cpp:7:24: error: expected ‘(’ before ‘=’ token
Int(int i = 0):m_i = i
^
test.cpp:7:24: error: expected ‘{’ before ‘=’ token
test.cpp: In function ‘int main()’:
test.cpp:19:13: error: no match for ‘operator+’ (operand types are ‘Int’ and ‘Int’)
S2 = S2 + S1;
^
test.cpp:20:21: error: no match for ‘operator<<’ (operand types are ‘std::basic_ostream’ and ‘Int’)
cout << “S2 = ” << S2 << endl;
^
由此看出，一般运算符对用户自定义类不适用，为了解决这一问题，C++中提出了运算符重在这一定义，用户可根据自己需求重新定义运算符。

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

运算符重载规则如下：
1、 C++中的运算符除了少数几个之外，全部可以重载，而且只能重载C++中已有的运算符。
【不能重载的运算符只有五个：
成员运算符： “.” ； 指针运算符： “ * ”
作用域运算符: “ :: ” ； “ sizeof ”；
条件运算符： “？：” 】
2、 重载之后运算符的优先级和结合性都不会改变。
3、 运算符重载是针对新类型数据的实际需要，对原有运算符进行适当的改造。一般来说，重载的功能应当与原有功能相类似，不能改变原运算符的操作对象个数，同时至少要有一个操作对象是自定义类型。
4、若一个运算符的操作需要修改对象的状态，选择重载为成员函数较好。
5、若运算符所需的操作数（尤其是第一个操作数）希望有隐式类型转换，则只能选用友元函数。
6、当运算符函数是一个成员函数时，最左边的操作数（或者只有最左边的操作数）必须是运算符类的一个类对象（或者是对该类对象的引用）。如果左边的操作数必须是一个不同类的对象，或者是一个内部 类型的对象，该运算符函数必须作为一个友元函数来实现。

一般情况下，单目运算符最好重载为类的成员函数；双目运算符则最好重载为类的友元函数。
C++提供4个类型转换函数：reinterpret_cast（在编译期间实现转换）、const_cast（在编译期间实现转换）、stactic_cast（在编译期间实现转换）、dynamic_cast（在运行期间实现转换，并可以返回转换成功与否的标志）。

运算符重载示例：

#include <iostream>
using namespace std;

class Int;

ostream& operator<<(ostream &out, const Int &i);

class Int
{
    //friend class Int;
    friend ostream& operator<<(ostream &out, const Int &i);
public:
    Int(int i = 0):m_i(i)
    {}
    ~Int()
    {}
public:
    /**********算术运算符***********/
    Int operator+(const Int &i);
    Int operator-(const Int &i);
    Int operator*(const Int &i);
    Int operator/(const Int &i)；
    Int operator%(const Int &i);
    Int operator^(const Int &i);
    Int operator++();              //++a
    Int operator++(int);           //a++ 
    Int& operator--();             //--a
    Int operator--(int);           //a--
    /***********赋值运算符***********/
    void operator+=(const Int &i);  
    void operator-=(const Int &i);
    void operator*=(const Int &i);
    void operator/=(const Int &i);
    void operator%=(const Int &i);
    Int& operator>>=(int n);              //>>=a   
    Int& operator<<=(int n);              //<<=a 
    Int& operator+();  //+a
    Int& operator-();  //-a
    /************位操作运算符***********/
    Int& operator~();  //~a
    Int& operator!();  //!a
    /************条件运算符*************/
    bool operator==(const Int &i)；
    bool operator<(const Int &i);
    bool operator>(const Int &i);
    bool operator<=(const Int &i);
    bool operator>=(const Int &i);
    /**************位操作运算符***********/
    Int& operator>>(int n);              //>>a   
    Int& operator<<(int n);              //<<a 
    Int operator&(const Int &i);
    Int operator|(const Int &i);
    /**************逻辑运算符************/
    bool operator&&(const Int &i);
    bool operator||(const Int &i);
private:
    int m_i;
};

ostream& operator<<(ostream &out, const Int &i)
{
    out << (i.m_i);
    return out;
}

Int Int::operator+(const Int &i)
{
    return Int(m_i + i.m_i);
}
Int Int::operator-(const Int &i)
{
    return Int(m_i - i.m_i);
}
Int Int::operator*(const Int &i)
{
    return Int(m_i * i.m_i);
}
Int Int::operator/(const Int &i)
{
    return Int(m_i / i.m_i);
}
void Int::operator+=(const Int &i)
{
    m_i += i.m_i;
}
void Int::operator-=(const Int &i)
{
    m_i -= i.m_i;
}
void Int::operator*=(const Int &i)
{
    m_i *= i.m_i;
}
void Int::operator/=(const Int &i)
{
    m_i /= i.m_i;
}
Int Int::operator%(const Int &i)
{
    return m_i % i.m_i;
}
Int Int::operator^(const Int &i)
{
    return m_i ^ i.m_i;
}
void Int::operator%=(const Int &i)
{
    m_i %= i.m_i;
}
void Int::operator^=(const Int &i)
{
    m_i ^= i.m_i;
}
#if 1
Int Int::operator++()              //++a
{
    m_i += 1;
    return *this;
}
#endif
Int Int::operator++(int)            //a++
{
    Int temp(m_i);
    m_i += 1;
    return temp;
}
Int& Int::operator--()              //--a
{
    m_i -= 1;
    return *this;
}
Int Int::operator--(int)            //a--
{
    Int temp(*this);
    m_i -= 1;
    return temp;
}
Int& Int::operator+()
{
    m_i = +m_i;
    return *this;
}
Int& Int::operator-()
{
    m_i = -m_i;
    return *this;
}
Int& Int::operator~()
{
    m_i = ~m_i;
    return *this;
}
Int& Int::operator!()
{
    m_i = !m_i;
    return *this;
}
bool Int::operator==(const Int &i)
{
    return m_i == i.m_i;
}
bool Int::operator!=(const Int &i)
{
    return m_i != i.m_i;
}
bool Int::operator<(const Int &i)
{
    return m_i < i.m_i;
}
bool Int::operator>(const Int &i)
{
    return m_i > i.m_i;
}
bool Int::operator<=(const Int &i)
{
    return m_i <= i.m_i;
}
bool Int::operator>=(const Int &i)
{
    return m_i >= i.m_i;
}
Int& Int::operator>>(int n)              //>>a
{
    m_i = m_i >> n;
    return *this;
}
Int& Int::operator<<(int n)              //<<a
{
    m_i = m_i << n;
    return *this;
}
Int& Int::operator>>=(int n)              //>>=
{
    m_i >>= n;
    return *this;
}
Int& Int::operator<<=(int n)              //<<=
{
    m_i <<= n;
    return *this;
}
Int Int::operator&(const Int &i)             
{  
    Int temp;
    temp.m_i = m_i & i.m_i;   
    return temp;
}
Int Int::operator|(const Int &i)
{
    Int temp;
    temp.m_i = m_i | i.m_i;
    return temp;
}
bool Int::operator&&(const Int &i)             
{
    return m_i && i.m_i;
}
bool Int::operator||(const Int &i)
{
    return m_i || i.m_i;
}

int main()
{
    Int S(10);
    Int S1(1);
    Int S2 = S / S1;
    Int S3(0);
    S3 = !S3; 
    cour << "S3 = " << 3S << endl;
    S3 ^= 3;
    cout << "S3 = " << S3 << endl;    
    cout << ++S3 + S1 << S3 << endl;
    cout << S1 + S3++ << S3 <<endl;

    cout << "S1 & S3 = " << S1 & S3 << endl;

    cout << "S1 | S3 = " << S1 | S3 << endl;

    if(S && S3){
        cout << "S && S3 is true!" << endl;
    }else{
        cout << "S && S3 is false" << endl;
    }
    if(S || S3){
        cout << "S || S3 is true!" << endl;
    }else{
        cout << "S || S3 is false!" << endl;
    }

    cout << "S = " << S << endl;;
    cout << "S1 = " << S1 << endl;
    cout << "S2 = " << S2 << endl;
    cout << "S3 = " << S3 << endl;

    S1 =  S1 >> 1;
    cout << "S1 >> 1, S1 = " << S1 << endl;
    S2 = S2 << 1;
    cout << "S2 << 1, S2 = " << S2 << endl;
    S1 <<= 1;
    cout << "S1 << 1, S1 = " << S1 << endl;
    S2 >>= 1;
    cout << "S2 >> 1, S2 = " << S2 << endl;    
}