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

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;
    sum += rhs;
    return sum;
}

vector<string> v;
v = {"a", "an", "the"};

// 把这个运算符添加到StrVec中
StrVec &StrVec::operator=(initializer_list<string> i1)
{
    // alloc_n_copy分配内存空间并从给定范围内拷贝元素
    auto data = alloc_n_copy(i1.begin(), i1.end());
    free();
    elements = data.first;
    first_free = cap = data.second;
    return *this;
}

// 作为成员的二元运算符：左侧运算对象绑定到隐式的this指针
Sales_data& Sales_data::operator+=(const Sales_data &rhs)
{
    units_sold += rhs.units_sold;
    revenue += rhs.revenue;
    return *this;
}

class StrVec {
public:
    std::string& operator[](std::size_t n)
        { return elements[n]; }
    const std::string& operator[](std::size_t n) const
        { return elements[n]; }
private:
    std::string *elements;
};

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

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

class StrBlobPtr {
public:
    std::string& operator*() const
    {
        auto p = check(curr, "deference past end");
        return (*p)[curr]; // (*p)是对象所指的vector
    }
    std::string* operator->() const
    {
        // 将实际工作委托给解引用运算符
        return & this->operator*();
    }
}

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

// 调用
absInt absObj;
int ui = absObj(-42);

class PrintString {
public:
    PrintString(osttream &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(vs.begin(), vs.end(), PrintString(cerr, '\n'));

function<int(int, int)>; // 声明一个function类型，表示接受两个int返回一个int的可调用对象

function<int(int, int)> f1 = add; // 函数指针
function<int(int, int)> f2 = divide(); // 函数对象类的对象
function<int(int, int)> f3 = [](int i, int j) { return i * j; } // lambda
cout << f1(4,2) << endl; // 打印6
cout << f2(4,2) << endl; // 打印2
cout << f3(4,2) << endl; // 打印8

// 列举了可调用对象与二元运算符对应关系的表格
// 可调用对象需要接收两个int，返回一个int
// 其中的元素可以是函数指针、函数对象或者lambda
map<string, function<int(int, int)>> binops;

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

// 调用方式
binops["+"](10, 5);  // 调用add(10, 5)
binops["-"](10, 5);  // 调用minus<int>对象的调用运算符
binops["/"](10, 5);  // 调用divide对象的调用运算符
binops["*"](10, 5);  // 调用lambda对象
binops["%"](10, 5);  // 调用lambda对象

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; // 指针指向的add是接收两个int的版本
binops.insert({"+", fp});  // 正确：fp指向一个正确的add版本

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

operator type() const;

// 构造函数将算数类型的值转换成SmallInt对象，而类型转换运算符将SmallInt对象转化成int
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;
};

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

int i = 42;
cin << i; // 如果向bool的类型转换不是显式的，则该代码在编译器看来将是合法的

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

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

// 最好不要在两个类之间构建相同的类型转换
struct B;
struct A {
    A() = dufault;
    A(const B&); // 把一个B转换成A
};

struct B {
    operator A() const; // 也是把一个B转换成A
};

A f(const A&);
B b;
A a = f(b); // 二义性错误：含义可能是f(B::operator A())还可能是f(A::A(const B&))

// 如果确实想执行上述的调用，那么就不得不显式地调用类型转换运算符或者转换构造函数
A a1 = f(b.operator A()); // 正确：使用B的类型转换运算符
A a2 = f(A(b)); // 正确：使用A的构造函数

a.operatorsym(b); // a有一个operatorsym成员函数
operatorsym(a, b); // operatorsym是一个普通函数

class SmallInt {
    friend SmallInt operator+(const SmallInt&, const SmallInt&);
public:
    SmallInt(int = 0); // 转换源为int的类型转换
    operator int() const { return val; } // 转换目标为int的类型转换
private:
    std::size_t val;
};

SmallInt s1, s2;
SmallInt s3 = s1 + s2; // 使用重载的operator
int i = s3 + 0; // 二义性错误：既可以把0转换成SmallInt，然后使用SmallInt的+；也可以将s3转换成int，对int执行内置的加法运算