C++ Primer 第十四章 重载运算与类型转换

//错误：不能为 int 重定义内置的运算符
int operator+(int, int);

//一个非成员运算符函数的等价调用
data1 + data2;  //普通的表达式
operator+(data1, data2);    //等价的函数调用

//一个成员运算符函数的等价调用
data1 +=data2;  //基于“调用”的表达式
data1.operator+(data2); //等成员运算符函数的等价调用

ostream &operat<< (ostream &os, const Sales_data &item)
{
    os << item.isbn() << " " << item.units_sold << " "
        << item.revenue << " " << item.avg_price();
    return os;
}

Sales_data data;
data << cout;    //如果 operator<< 是 Sales_data 的成员

istream &operator>>(istream &is, Sales_data &item)
{
    double price;   //不需要初始化，因为我们将先读入数据到 price，之后才使用它
    is >> item.bookNo >> item.units_sold >> price;
    if (is) //检查输入是否成功
        item.revenue = item.units_sold * price;
    else
        item = Sales_data();    //输入失败：对象被赋予默认的状态
    return is;
}

Sales_data operator+(const Sales_data &lhs, const Sales_data &rhs)
{
    Sales_data sum = lhs;   //把lhs的数据成员拷贝给sum
    sum += rhs; //将rhs加到sum中
    return sum;
}

bool operator==(const Sales_data &lhs,const Sales_data &rhs)
{
    return lhs.isbn() == rhs.isbn() &&
            lhs.units_sold == rhs.units_sold &&
            lhs.revenue == rhs.revenue;
}
bool operator!=(const Sales_data &lhs, const Sales_data &rhs)
{
    return !(lhs == rhs);
}

//作为成员的二元运算符：左侧运算对象绑定到隐式地 this 指针
//假定两个对象表示的是同一本书
Sales_data& Sales_data::operator+=(const Sales_data &rhs)
{
    units_sold += rhs.units_sold;
    revenue += rhs.revenue;
    return *this;
}

class StrBlobPtr{
public:
    //递增和递减运算符
    StrBlobPtr& operator++();   //前置运算符
    StrBlobPtr& operator--();
    //其他成员和之前版本一致
};

//前置版本：返回递增/递减对象的引用
StrBlobPtr& StrBlobPtr::operator++()
{
    //如果curr已经指向了容器的尾后位置，则无法递增它
    check(curr, "increment past end of StrBlobPtr");
    ++curr; //将curr在当前状态下向前移动一个元素
    return *this;
}
StrBlobPtr& StrBlobPtr::operator--()
{
    //如果curr是0，则继续递减它将产生一个无效下标
    --curr; //将curr在当前状态下向后移动一个元素
    check(curr, "decrement past begin of StrBlobPtr");
    return *this;
}

class StrBlobPtr{
public:
    //递增和递减运算符
    StrBlobPtr operator++(int); //后置运算符
    StrBlobPtr operator--(int);
    //其他成员和之前版本一致
};

//后置版本：递增/递减对象的值但是返回原值
StrBlobPtr StrBlobPtr::operator++(int)
{
    //此处无须检查有效性，调用前置递增运算时才需要检查
    StrBlobPtr ret = *this; //记录当前的值
    ++*this;    //向前移动一个元素，前置++需要检查递增的有效性
    return ret; //返回之前记录的状态
}
StrBlobPtr StrBlobPtr::operator--(int)
{
    //此处无须检查有效性，调用前置递减运算时才需要检查
    StrBlobPtr ret = *this; //记录当前值
    --*this;    //向后移动一个元素，前置--需要检查递减的有效性
    return ret; //返回之前记录的状态
}

StrBlobPtr p(a1);   //p 指向 a1 中的 vector
p.operator++(0);    //调用后置版本的 operator++
p.operator++();     //调用前置版本的 operator++

class StrBlobPtr{
public:
    std::string& operator*() const
    {
        auto p = check(curr, "dereference past end");
        return (*p)[curr];  //(*p)是对象所指的 vector
    }
    std::string* operator->() const
    {
        //将实际工作委托给解引用运算符
        return & this->opreator*();
    }
    //其他成员与之前的版本一致
};

struct absInt{
    int operator()(int val) const{
        return val > 0 ? val:-val;
    }
};

int i = -42;
absInt absObj;  //含有函数调用运算符的对象
int ui = absObj(i); //将 i 传递给 absObj.operator()

class PrintString{
public:
    PrintString (ostream &o = cout, char c = ' '):os(o), sep(c){}
void operator()(const string &s) const {os << s << sep;}
private:
    ostream &os;    //用于写入的目的流
    char sep;   //用于将不同输出隔开的字符
};

PrintString printer;    //使用默认值，打印到 cout
printer(s); //在 cout 中打印 s，后面跟一个空格
PrintString errors(cerr, '\n');
errors(s);  //在 cerr 中打印 s，后面跟一个换行符

//例如可以使用标准库 for_each 算法和我自己的 PrintString 类来打印容器内容
for_each(vs.begin(), vs.end(), PrintString(cerr, '\n'));

stable_sort(words.begin(), words.end(),
            [](const string &a, const &b)
            {return a.size() < b.size();});
//其行为类似于下面这个类的一个未命名对象
class ShorterString {
public:
    bool operator()(const string &s1, const string &s2) const
    {return s1.size() < s2.size();}
};

//svec 是一个 vector<string>
//传入一个临时的函数对象用于执行两个 string 对象的 > 比较运算
sort(svec.begin(), svec.end(), greater<string>());

vector<string *> nameTable;
sort(nameTable.begin(), nameTable.end(), [] (string *a, sting *b { return a < b; }));   //错误
sort(nameTable.begin(), nameTable.end(), less<string *>()); //正确

//普通函数
int add(int i, int j) { return i + j; }
//lambda，其产生一个未命名的函数对象类
auto mod = [] (int i, int j) { return i % j; }
//函数对象类
struct divide{
    int operator()(int denominator, int divisor){
        return denominator / divisor;
    }
}

map<string, int(*)(int, int)> binops;
binops.insert({"+", add});  //正确，add 是一个指向正确类型函数的指针
binops.insert({"%",mod});   //错误，mod 不是一个函数指针

map<string, function<int(int, int)>> binops = {
    {"+", add}, //函数指针
    {"-", std::minus<int>()},   //标准库函数对象
    {"/", divide()},    //未命名的 lambda
    {"*", [] (int i, int j) { return i * j; }}, //命名了的 lambda
    {"%", mod}};    //

int add(int i, int j) { return i + j; }
Sales_data add(const Sales_data&, const Sales_data&);
map<string, function<int(int, int)>> binops;
binops.insert({"+", add});  //错误，哪个 add？

int (*fp)(int, int) = add;
binops.insert({"+",fp});

binops.insert({"+", [] (int i, int j) { return add(i, j); }});

operator type() const;

class SmallInt {
public:
    SmallInt(int i = 0): val(i)
    {
        if (i < 0 || i > 255)
            throw std::out_of_range("Bad SmallInt value");
    }
    operator int() const { return val; }
private:
    std::size_t val;
};

SmallInt si;
si = 4;    //首先将4隐式地转换成 SmallInt，然后调用 SmallInt::operator=
si + 3;    //首先将 si 隐式地转换成 int，然后执行整数的加法

//内置类型转换将 double 实参转换为 int
SmallInt si = 3.14; //调用 SmallInt(int) 构造函数
//SmallInt 的类型转换运算符将 si 转换为 int
si + 3.14;  //内置类型转换将所得的 int 继续转换成 double

int i = 42;
cin << i;

class SmallInt {
public:
    //编译器不会自动执行这一类型转换
    explicit operator int() const { return val; }
    //其他成员与之前的版本一致
};

SmallInt si = 3;    //正确：SmallInt 的构造函数不是显式的
si + 3; //错误：此处需要隐式的类型转换，但类的运算符是显式的
static_cast<int>(si) + 3;   //正确：显式地请求类型转换