读书笔记（C++）————【重载操作符与转换】

//14.重载操作符与转换

//14.1 重载操作符的定义

    //不能重载的操作符
    ::  .*  .   ?:

    //重载操作符必须具有至少一个类类型或枚举类型的操作数

    //优先级和结合性是固定的

    //不再具备短路求值特性，重载&&和||不是好做法

    //作为类成员函数的重载函数，形参比操作数少一，隐含this形参作为第一个操作数

    //一般将算数和关系操作符定义为非成员，而将赋值操作符定义为成员

    //也可以像普通函数一样调用重载操作符函数
    cout << operator+(item1,item2) << endl;
    //等效
    cout << item1 + item2 << endl

    //尽量避免重载 , & && || 操作符

    //若重载算数操作符（+），应同时重载复合赋值符（+=）

    //必须定义为成员的操作符：= [] () ->

//14.2 输入输出操作符

    //Sale_item重载输出操作符,不应输出换行符
    ostream&
    operator<<(ostream& out,const Sales_item& s)
    {
        out << s.isbn << "\t" << s.units_sold << "\t"
            << s.revenue << "\t" << s.avg_price();
        return out;
    }

    //IO操作必须为非成员函数，因为左操作数必须是类类型对象

    //Sale_item重载输入操作符
    istream&
    operator<<(istream& in, Sales_item& s)
    {
        double price;
        in >> s.isbn >> s.units_sold >> price;
        if(in)
            s.revenue = s.unit_sold * price;
        else
            s = Sale_item();//input failed:reset object to default state
        return out;
    }

    //相等操作符
    inline bool
    operator==(const Sale_item& c1,Sale_item& c2)
    {
        return c1.units_sold == c2.units_sold &&
               c1.revenue == c2.revenue &&
               c1.same_isbn(c2);
    }
    inline bool
    operator!=(const Sale_item& c1,Sale_item& c2)
    {
        return !(c1 == c2);
    }

//14.4 赋值操作符

    //赋值操作符可重载且必须返回*this引用

//14.6 成员访问操作符

    //#include <iostream>
    using namespace std;

    class A{
    public:
        void action(){
            cout << "Action in class A!" << endl;
        }
    };

    class B{
        A a;
    public:
        A* operator->(){
            return &a;
        }
        void action(){
            cout << "Action in class B!" << endl;
        }
    };

    class C{
        B b;
    public:
        B operator->(){
            return b;
        }
        void action(){
            cout << "Action in class C!" << endl;
        }
    };

    int main(int argc, char *argv[])
    {
        C* pc = new C;
        pc->action();
        C c;
        c->action();
        getchar();
        return 0;
    }
    /*上面代码输出结果是：
     *Action in class C!
     *Action in class A!
     */
//14.7 自增操作符和自减操作符

    //调用后置++需要给出一个整形实参
    c.operator++(0);

    //调用操作符()和函数对象,必须声明为成员函数。
    class absInt
    {
        int operator()(int val)
        {
            return val > 0 : -val : val;
        };
    };

//14.8.1 将函数对象用于标准算法

    //函数对象比函数更灵活，容易修改程序以根据其他值进行测试。例：
    //函数：
    bool GT6(const string &s)
    {
        return s.size() >= 6;
    }
    vector<string>::size_type wc =
            count_if(words.begin(),words.end(),GT6);
    //函数对象：
    class GT_cls
    {
    public:
        GT_cla(int val = 0):bound(val){}
        bool operator()(const string &s)
        {
            return s.size() >= bound;
        }
    private:
        string::size_type bound;

    };
    cout << count_if(words.begin(),words.end(),GT_cla(6))
         << " words 6 characters or longer" << endl;
//14.8.2 标准库定义的函数对象#include<functional>

    //表 14 - 3 标准库函数对象
    类型                 函数对象                所应用的操作符
算术函数对象类型    plus<Type>                   +
                    minus<Type>                  -  //接受一个实参
                    multiplies<Type>             *
                    divides<Type>                /
                    modulus<Type>                %
                    negate<Type>                 -
关系函数对象类型    equal_to<Type>               ==
                    not_equal_to<Type>           !=
                    greater<Type>                >
                    greater_equal<Type>          >=
                    less<Type>                   <
                    less_equal<Type>             <=
逻辑函数对象类型    logical_and<Type>            &&
                    logical_or<Type>             |
                    logical_not<Type>            !  //接受一个实参

    //每个类都定义了应用名操作的调用操作符
    plus<int> intAdd;
    int sum = intAdd(10,20);//sum = 30;

    //函数对象常用于覆盖算法使用的默认操作符。例如，sort默认使用
    //operator<按升序对容器进行排序。为了按降序对容器进行排序，
    //可以传递函数对象greater。该类将产生一个调用操作符，调用基础对象的大于操作符。
    //如果svec是一个vector<string>对象，以下代码将降序排列
    sort(svec.begin(),svec.end(),greater<string>());

//14.8.3 函数对象的函数适配器

    //两类：1.绑定器  bind1st   bind2nd
    //      2.求反器   not1(求反一元函数对象真值)    not2（求反二元函数真值）

    //计算一个容器中所有小于或等于10的值,适配器返回一个函数对象
    count_if(vec.begin(),vec,end(),bind2nd(less_equal<int>(),10)));
    count_if(vec.begin(),vec,end(),not1(bind2nd(less_equal<int>(),10))));

//14.9.2 转换操作符

    //不允许转换数组或函数，可转换为指针以及引用
    class SmallInt
    {
    public:
        SmallInt(int i = 0):val(0)
        {
            if(i < 0 || i > 255)
                throw std::out_of_range("Bad SmallInt Initialize")
        }
        operator int() const{return val;}
    private:
        std::size_t val;
    };


    //使用类类型转换
    SmallInt si;
    double dval;
    si >= dval;   //si converted to int and then convert to double

    if(si)      //si converted to int and then convert to bool

    //只能应用一个类类型转换

    //它可以转换为SmallInt，但不能转换成Int
    class Intergral
    {
        Intergral(int i = 0):val(i){}
        operator SmallInt() const {return val % 256;}
    private:
        std::size_t val;
    };

    int calc(int);
    Integral inVal;
    SmallInt si(intVal);    //ok
    int i = calc(si)        //ok
    int j = calc(intVal)    //error

    //标准转换可放在类类型转换之前

//14.9.3 实参匹配和转换

    //待续

    //

    //

    //

    //

    //

    //

    //

    //

    //

    //

    //

    //

    //

    //

    //

    //

    //

    //

    //

    //

    //

    //

    //

    //

    //