- l 通常情况下，不应该重载逗号、取地址、逻辑或与运算符，这样可能会改变求值顺序、短路特性。对于逗号、取地址运算符，重载之后还会改变内置的含义。
- l 运算符重载可以定义在类，是内成员函数，也可以是非成员函数。当做为成员函数定义时，this会默认成为第一个参数，绑定到左侧运算对象。
- l 需要改变左侧运算对象状态、访问左侧运算对象内容，必须定义成成员函数。
- l 具有对称性的运算、可能发生转换任意一端的运算，一般应该定义成非成员
14.2输入输出运算符
- l 输入输出运算符必须是非成员函数，这样第一个参数才会是运算符左侧的stream
- l 输入输出运算符的第一个参数应该是stream的非const引用(写入或读取会改变stream状态)，在函数最后返回(实现链式调用)。
- l 通常需要读写类的private成员，所以一般声明为友元函数
- l 输入运算符需要处理可能的错误，而输出运算符一般不需要
class ClassName { friend ostream& operator<<(ostream&, ClassName&); friend istream& operator>>(istream&, ClassName&); private: string name; }; ostream& operator<<(ostream& os, ClassName& obj) { os << obj.name; return os; } istream& operator>>(istream& is, ClassName& obj) { is >> obj.name; //处理输入错误 //设置foilbit、eofbit、badbit return is; }
14.3算术关系运算符
- l 算术运算符一般不需要改变运算对象内容，并且要允许左侧运算对象进行类型转换，所以一般都是非成员函数，形参为const引用
- l 算术运算一般会得到新值，新值是局部变量，所以返回其副本作为结果（不能返回引用）
- l 一般来讲会定义对应的复合赋值运算，可以使用之进行算术运算（用其中一个对象构造副本，对副本使用复合赋值运算符，返回副本）
- l 相等运算符和不等运算符应该成对出现，并且使用其中一个进行比较就可以了。而且，如果定义了相等/不等运算符，标准库容器和算法也可以使用了。
- l 关系运算符定义了顺序关系，应该与关系容器中对关键字的要求一致（参见有序容器的要求：严格弱化的”<”操作）
- l 如果有==运算符，则关系运算应该与之保持一致，特别是当对象!=时，必定有less than的一个。
Sales_data operator+(const Sales_data &lhs, const Sales_data &rhs) { Sales_data sum = lhs; // copy data members from lhs into sum sum += rhs; // add rhs into sum return sum; } bool operator==(cons tSales_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); }
14.4赋值运算符
在拷贝控制中讲解了赋值运算符的拷贝赋值和移动赋值，还有一种是使用花括号列表进行赋值。
vector<string> vec; vec = { "123" ,"456","789" };
对于之前编写的动态内存管理类，我们可以添加这个赋值特性
//列表赋值运算符 StrVec &operator= (std::initializer_list<std::string> ls) { auto data = alloc_n_copy(ls.begin(), ls.end()); free(); elements = data.first; first_free = cap = data.second; return *this; }
14.5下标运算符
下标运算符通常定义两个版本，一个是const版本，另一个是nonconst版本。
下标运算符必须是成员函数。
//下标运算符 std::string&operator[](std::size_t n) { return elements[n]; } const std::string& operator[](std::size_t n) const { return elements[n]; }
14.6自增自减运算符
There are both prefix and postfix versions. These operators usually should be defined as members.
- 对于迭代器自增自减的时候，需要检查边界。
- 前置返回值为引用，后置返回值为值。
- 后置多了一个int参数，但是没有使用，在执行的时候使用了前置的函数。
class StrBlobPtr { public: // increment and decrement StrBlobPtr&operator++(); // prefix operators StrBlobPtr&operator--(); StrBlobPtr operator++(int); // postfix operators StrBlobPtr operator--(int); // other members as before }; // prefix:return a reference to the incremented/decremented object StrBlobPtr& StrBlobPtr::operator++() { // if curr already points past the end of the container, can't increment it check(curr, "increment past end of StrBlobPtr"); ++curr; // advance the current state return*this; } StrBlobPtr& StrBlobPtr::operator--() { // if curr is zero, decrementing it will yield an invalid subscript --curr; // move the current state back one element check(-1, "decrement past begin of StrBlobPtr"); return*this; } // postfix: increment/decrementthe object but return the unchanged value StrBlobPtr StrBlobPtr::operator++(int) { // no check needed here; the call to prefix increment will do the check StrBlobPtrret = *this; // save the current value ++*this; // advance one element; prefix ++ checks the increment returnret; // return the saved state } StrBlobPtr StrBlobPtr::operator--(int) { // no check needed here; the call to prefix decrement will do the check StrBlobPtrret = *this; // save the current value --*this; // movebackward one element; prefix -- checks the decrement returnret; // return the saved state }
14.7成员访问运算符
在迭代器类以及智能指针类中，拥有成员访问运算符，包括解引用运算符、箭头运算符。
对于内置的指针类型，访问其成员我们使用(*ptr).mem，使用ptr->men与之等价，“ptr->”实际上就成为了“(*ptr).”。
对于定义了->运算符的对象，我们使用*和->都将使用自定义的版本。
- operator*可以当做一个一般的函数进行调用。
- operator->在函数调用完成后有附加动作。如果他返回的结果是一个内置指针，则在函数调用完成之后，对返回的内置指针执行->操作；如果返回的结果本身含有重载的operator->，则继续执行返回对象的operator->调用过程。（所以，其返回值必须是一个内置指针或者重载了operator->操作的对象）
class Ptr { std::string& operator*() const { auto p = check(curr, "dereference past end"); return(*p)[curr]; // (*p) is the vector to which this object points } std::string*operator->() const {// delegate the real work to the dereference operator return&this->operator*(); } };
14.8函数调用运算符
Objects of classes that define the call operator are referred to as function objects. Such objects “act like functions” because we can call them.
class absInt { public: int operator()(int integer) { return integer > 0 ? integer : -integer; } }; int main() { absInt funObj; int b = funObj(-155); }
14.8.1函数调用与lambda表达式
lambda表达式实际上就是一个函数对象，捕获列表中的数据将会成为对象的成员。
14.8.2标准库的函数对象
Arithmetic算术
|
plus<Type> |
minus<Type> |
multiplies<Type> |
divides<Type> |
modulus<Type> |
negate<Type> |
Relational关系
|
equal_to<Type> |
note_equal_to<Type> |
greater<Type> |
greater_equal<Type> |
less<Type> |
less_equal<Type> |
Logical逻辑
|
logical_amd<Type> |
logical_or<Type> |
logical_not<Type> |
默认情况下sort使用<进行排序，为降序。可以如下使用升序。
#include<functional> sort(svec.begin(), svec.end(), greater<string>());
14.8.3可调用对象与function
调用形式（call signature）：int(int,int)
不同的类型，具有相同的调用形式
//普通函数 int add(int i, int j) { return i + j; } //lambda，其产生一个未命名的函数对象类 auto add = [](int i, int j) { return i + j; }; //函数对象类 class add { int operator()(int i, int j) { return i + j; } };
这种调用形式，可以用一种模板类型代替
#include<functional> function<int(int, int)> fun;
function不能识别重载函数
//普通函数 int add(int i, int j) { return i + j; } double add(int i, double j) { return i + j; } //这句话会出错 function<int(int, int)> fun = add;
函数指针可以识别重载
//函数指针可以识别重载 int(*f)(int, int) = add; function<int(int, int)> fun = f;
14.9重载、类型转换与运算符
转换构造函数（将其他类型转换成自己）
构造函数只接受一个实参，实际上定义了此类型的隐式转换机制。当然，可以使用explicit声明阻止这个转换。
隐式类型转换运算符（将自己转换成其他类型）
operator type() const;
- 转换成可以作为函数返回值的类型（除了void、当然不包括数组、函数类型）
- 没有显式返回值（通常返回值是类型转换运算符自己），没有形参
- 一般不应该改变待转换对象的内容，所以定义成const
class SmallInt { public: operator int()const { return val; } private: std::size_t val; };
显式类型转换运算符（将自己转换成其他类型）
explicit operator type() const;
如果表达式用在条件语句，则会隐式执行
- if、else if、while、do、for的条件部分
- 逻辑!、||、&&的运算对象
- ?:的条件表达式
class SmallInt { public: explicit operator int()const { return val; } private: std::size_t val; } int main() { SmallInt si; int a = static_cast<int>(si); }
转换为bool
while(std::cin>>value)
cin的>>运算符返回cin本身，因为在条件语句，隐式转换成bool类型。
非条件语句中，如cin<<2，因为cin没有定义<<、如果cin可以隐式转换成bool，则可以将<<用作左移符号。但是非条件语句，不能隐式转换，所以这句话是错误的。
14.9.2避免二义性的类型转换
- A有转换构造函数，将B转换成A。同时，B定义了转换运算符，可以将B转换成A类型。则在用到B转换为A的语句时，不能确定适用的函数。
- 所有算术类型的转换级别都是相同的，若A由转换构造函数，将int/double转换为A，则给定long long类型转换成A就会错误(long类型可能直接使用int转换，因为某些编译器中long和int是同一类型，如visual C++)；同理，转换运算符也会有这个问题。
- 对于2，可以只定义一个算术类型的转换，如果使用时需要转换成其他算术类型，编译器会自动使用内置的转换。
The easiest rule of all: With the exception of an explicitconversion to bool, avoid defining conversion functions and limit nonexplicit constructors to those that are “obviously right.”
- 若一组重载的函数接收A、B类型的参数，A、B类型都有接收int类型的转换构造函数，则int类型做参数调用这个函数的时候，会出现二义性。（这通常意味着A、B类设计存在不足）
- 如果重载函数接收C类型参数，C类型有接收double类型的转换构造函数，则仍会出现二义性，因为抵用额外标准类型转换后再调用自定义转换级别是相同的。
14.9.3函数匹配与重载运算符
当我们使用内置类型与类类型进行运算的时候，若有运算符重载和类定义的类型转换，则可能会发生二义性。
A定义了参数为int的转换构造函数和转换为int的类型转换函数，并且有重载的运算符+，则A的对象a进行运算a+10就会产生二义性，无法确定是对a转换成int进行的内置加法，还是10转换成A的重载加法。