操作符重载集锦

在C++中约定，对于++操作符重载 ，将不带参数的作为前项++，将带有一个int类型亚参数的重载作为后项++。

 

 

#include  < iostream >
using   namespace  std;


class  Data
... {
private:

    int d;

public:

    Data(void) : d(0)
    ...{

    }

    Data(int i) : d(i)
    ...{

    }

    Data(const Data& data) : d(data.d)
    ...{

    }

    Data& operator = (const int i)
    ...{
        d = i;
        return *this;
    }

    Data& operator = (const Data& data)
    ...{
        d = data.d;
        return *this;
    }

    bool operator == (const int i)const
    ...{
        return d == i;
    }

    bool operator == (const Data & data)const
    ...{
        return data.d == d;
    }

    operator int(void)const
    ...{
        return d;
    }

    Data operator + (int i)const
    ...{
        return Data(d + i);
    }

    Data& operator += (int i)
    ...{
        d += i;
        return *this;
    }

    Data& operator += (const Data& data)
    ...{
        d += data.d;
        return *this;
    }

    Data operator << (const int i)const
    ...{
        return Data(d << i);
    }

    Data& operator <<= (const int i)
    ...{
        d <<= i;
        return *this;
    }

    Data operator >> (const int i)const
    ...{
        return Data(d >> i);
    }

    Data& operator >>= (const int i)
    ...{
        d >>= i;
        return *this;
    }

    Data* operator -> (void)
    ...{
        d--;
        return this;
    }

    Data& operator * (int i)
    ...{
        d *= i;
        return *this;
    }

    Data& operator * (const Data& data)
    ...{
        d *= data.d;
        return *this;
    }

    void operator() (void)
    ...{
        cout << "This is a data!" << endl;
    }

    friend ostream& operator << (ostream& out, const Data* data);

    friend int operator + (int i, const Data& data);

    int GetData(void)const
    ...{
        return d;
    }
} ;


int   operator   +  ( int  i,  const  Data &  data)
... {
    return i + data.d;
}


ostream &   operator   <<  (ostream &   out ,  const  Data *  data)
... {
    out << data->d + 100 << endl;
    return out;
}


class  Number
... {
private:

    Data *pData;

    int n;

public:

    explicit Number(void) : pData(NULL), n(0)
    ...{

    }

    explicit Number(Data *p) : pData(p), n(1)
    ...{

    }

    Data& operator * (void) const
    ...{
        return *pData;
    }

    int GetData(void) const
    ...{
        return n;
    }
} ;


int  main( void )
... {
    cout << "The answer is: " << 3 + Data(5) << endl;

    Data d(5);

    cout << d << endl;

    cout << &Data(10) << endl;

    cout << "Hey, " << Data(0)->GetData() << endl;

    Data d2 = 3 + d - 4;

    cout << "Hoo, " << d2->GetData() << endl;

    Data *p = &d;

    d = d * d2;

    cout << "The data is: " << (*p).GetData() << endl;

    d();

    Number n(&d);

    cout << "The answer is: " << (*n).GetData() << endl;
    cout << "The answer is: " << n.GetData() << endl;

    return 0;
}