第14章 操作符重载与类型转换(C++ Primer 5th)

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

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

ostream& operator<<(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;
}

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!(1hs==rhs);
}

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;//指向数组首元素的指针
};

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->operator*();
    }
    //...
}

struct absInt {
    int operator()(int val) const {
        return val < 0 ? -val : val;
    }
}；
// 使用
int i = -42;
absInt absObj;
int ui = absObjs(i);

//根据单词的长度对其进行排序，对于长度相同的单词按照字母表顺序排序
stable_sort(words.begin(),words.end(),
			[](const string &a, const string &b)
				{return a.size()<b.size();});
// 其行为类似于下面代码
class ShorterString {
public:
    bool operator()(const string &s1, const string &s2) const
    { return s1.size()<s2.size(); }
};

stable_sort(words.begin(),words.end(),ShorterString());

//获得第一个指向满足条件元素的迭代器，该元素满足size()is>=sz
auto wc = find_if (words.begin(),words.end(),
					[sz](const string &a)
						{return a.size()>=sz;});
// 该lambda 表达式产生的类如下
class SizeComp {
    SizeComp(size_t n):sz(n){ }//该形参对应捕获的变量
    //该调用运算符的返回类型、形参和函数体都与lambda一致
    bool operator()(const string &s) const
    {return s.size()>=sz;}
private:
    size_t sz;//该数据成员对应通过值捕获的变量
};

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

int(int, int);  // 是一个函数类型，接受两个int， 返回一个int

// 普通函数
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;
  }  
};

// 构建从运算符到函数指针的映射关系，其中函数接受两个int、返回一个int
map<string, int(*)(int, int)> binops;

// 添加可调用对象到函数表
binops.insert({"+", add});		// 正确
binops.insert({"%", mod});		// 错误， mod 不是一个函数指针

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

// 将不同的可调用对象添加到map
map<string,function<int(int,int)>>binops={
    
    {"+",add},							//函数指针
    {"-",std::minus<int>()},			//标准库函数对象
    {"/",divide()},  					//用户定义的函数对象
    {"*",[](int i,int j){return i*j;}}, //未命名的lambda
    {"%",mod} 							//命名了的lambda对象
};
// 调用
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版本
//正确：使用lambda来指定我们希望使用的add版本
binops . insert ( { " + " , [ ] ( int a , int b ) { return add ( a , b ) ; } } ) ;

operator type() const ;

class SmallInt {
public:
    SmallInt(int i=0):val(i)
    {
        if (i < 0 11 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;//如果向bool的类型转换不是显式的，则该代码在编译器看来将是合法的！

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

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

while(std::cin >> value)

#if __cplusplus >= 201103L
      explicit
#endif
      operator bool() const
      { return _M_ok; }
    };

//最好不要在两个类之间构建相同的类型转换
struct B;
struct A {
    A()=default;
    A(const B&);//把一个B转换成A
    //...
    };
struct B {
    operatorA()const;//也是把一个B转换成A
    //...
};
A f(const A&);
Bb;
Aa=f(b);//二义性错误：含义是f(B::operator A())
		//还是f(A:A(const B&))?
// 显式调用
A a1 = f (b.operator A());//正确：使用B的类型转换运算符
Aa2=f(A(b));//正确：使用A的构造函数