操作符重载

/*操作符重载*/

#include "stdafx.h"
#include <iostream.h>

class Interger
{
private:
    int m_nData;
public:
    int GetData() const
    {
        return m_nData;
    }
    int Add( int nData )
    {
        return m_nData + nData;
    }
public:
    //带参构造
    Interger(int nData)
    {
        m_nData = nData;
    }
    //拷贝构造
    Interger( const Interger& Obj )
    {
        m_nData = Obj.m_nData;       
        cout << "无名对象地址" << this << endl;
    }
public:
    //全局函数做运算符重载函数 友元声明
    friend Interger operator+ ( int nData , const Interger& Obj );
    //成员函数做为  运算符重载函数
    int operator+ ( int nData )
    {
        return m_nData + nData;
    }
   //返回类型，是否是引用要看操作符的含义
    //这种返回会产生无名对象并调用拷贝构造
    Interger operator+ ( const Interger& Obj )
    {
        Interger temp(m_nData);
        temp.m_nData += Obj.m_nData ;
        cout << "temp地址" << &temp << endl;
        return temp;
    }
   
    //a++
    //有一个形参类型,可以不写形参名
    Interger operator++(int)
    {
        //先引用,后自增,所以先保存一下当前值
        Interger temp(m_nData);
        m_nData++;
        //再返回保存下来的当前值
        return temp;
    }
   
    //++a
    //没有形参
    Interger operator++()
    {
        m_nData++;
        return *this;
    }
};

//全局函数做为运算符重载函数,声明为类的友元了
Interger operator+ ( int nData , const Interger& Obj )
{
   //常引用转换成不是常引用
    return ((Interger&)Obj + nData);
}

//基本数据类型的运算符的含义，已经确定不能重载
//int operator+ ( int nData1 , int nData2 )
//{
//    return nData1 + nData2;
//}

int main(int argc, char* argv[])
{
    Interger a(10),b(20),c(30),d(50);
    //这种写法很乱,用重载运算符解决
    //cout << d.Add(c.Add(a.Add(b.GetData()))) << endl;
   
    cout << "a地址" << &a << endl;
    cout << "b地址" << &b << endl;
   
    //操作符重载不能改变，操作符的内在含义
    //所以这种写法实际是会执行带参构造
    b = 1 + 1;
    //这种写法会执行带参构造.a+1的返回值为int值
    b = a + 1;

    Interger temp(0);
    //等同与这种写法temp = (a.operator+(b)).operator+(c);
    temp = a + b + c;  
    cout << temp.GetData() << endl;   
   
    //单目运算符，前++,后++
    c = a++;
    d = ++a;
   
    return 0;
}