运算符重载复习

分为：双目运算符重载：> < ==

        单目运算符重载：++  --  ()

        流运算符的重载

1、双目运算符重载

#include <iostream>
#include <string>
using namespace std;

class A
{
public:
    A(string s):str(s) {}
    friend bool operator < (const A &a1,const A &a2)
    {
        if(a1.str < a2.str)
            return true;
        else
            return false;
    }
public:
    string  str;
};

int main()
{
    A s1("123");
    A s2("234");
    cout << (s1 <s2) << endl;
    return 0;
}

2、单目运算符重载

　前置与后置的区别：如果形参为空就是前置，如果在形参中增加一个int型形参，那么就是后置。【调式可以看出他们调用函数的不同...】

#include <iostream>
#include <string>
using namespace std;

class A
{
public:
    A(int s):value(s) {}
    A operator++()
    {
        ++value;
        return *this;
    }
    A operator++(int a)
    {
        value++;
        return *this;
    }
public:
    int  value;
};

int main()
{
    A a(1);
    cout << (a++).value << endl;  //2
    cout << (++a).value <<endl;   //3
    return 0;
}

小括号运算符

//实例是转载的.
#include <iostream>
using namespace std;

class Time
{
public:
    int h;
    int m;
    int s;

    Time( int h = 0, int m = 0, int s = 0 )
    {
        operator()(h,m,s);
    }

    //小括号重载 版本0 注意和下面用户自定义转换的区别
    int operator()()
    {
        return h*3600 + m*60 + s;
    }

    //用户自定义转换
    operator int()
    {
        return h*3600 + m*60 + s;
    }

    //小括号重载 版本1
    void operator()(int h)
    {
        operator()(h,0,0);
    }

    //小括号重载 版本2
    void operator()(int h, int m)
    {
        operator()(h,m,0);
    }

    //小括号重载 版本3
    void operator()(int h, int m, int s)
    {
        this->h = h;
        this->m = m;
        this->s = s;
    }

    friend ostream & operator << ( ostream & os, const Time & t )
    {
        os << t.h << "::";
        if ( t.m < 10 )
        {
            os << '0';
        }
        os << t.m << "::";
        if ( t.s < 10 )
        {
            os << '0';
        }
        os << t.s;
        return os;
    }
};

int main()
{
    /*
    ** 注意：t(1),t(1,1),t(1,1,1)的用法
    ** 像不像“函数调用”
    ** 这样的用法称之为仿函数
    ** 仿函数在STL里用得特别多
    */
    Time t;
    cout << t << endl;
    t(1);                    //小括号重载 版本1
    cout << t << endl;
    t(1,1);                  //小括号重载 版本2
    cout << t << endl;
    t(1,1,1);                //小括号重载 版本3
    cout << t << endl;
    cout << t() << endl;     //小括号重载 版本0
    cout << int(t) << endl;  //用户自定义转换[注意]
    return 0;
}

3、流运算符重载

#include <iostream>
using namespace std;

class A
{
public:
    A() {}
    A(int a,int b):key1(a),key2(b) {}
    /*
    ** friend istream& operator >> (istream&  ,自定义类型) 这是流运算符重载的固定格式
    */
    friend istream& operator >> (istream &is,A &n)
    {
        is >> n.key1;
        is >> n.key2;
        return is;
    }
    /*
    ** friend ostream& operator >> (ostream&  ,自定义类型) 这是流运算符重载的固定格式
    */
    friend ostream& operator << (ostream &out,A &n)
    {
        out << n.key1<<endl;
        out << n.key2;
        return out;
    }
protected:
    int key1;
    int key2;
};

int main()
{
    A a(1,2);
    cout << a << endl;
    A b;
    cin >> b;
    cout << b << endl;
    return 0;
}