function类模版
function是一个模版。与我们使用的其他模版一样，当我们创建一个function类型时我们必须指定额外的信息。在这种情况下，该信息是该特定function类型可以表示的对象的调用签名。与其他模板一样，我们在尖括号内指定类型：
Code:
function<int(int, int)>
这里我们声明了一个function类型，它可以表示返回int结果并具有两个int参数的可调用对象。我们可以使用该类型来表示任何桌面计算器类型：
Code:
function<int(int, int)> f1 = add; // function pointer
function<int(int, int)> f2 = div(); // object of a function-object class
function<int(int, int)> f3 = [](int i, int j) // lambda
{ return i * j; };
cout << f1(4,2) << endl; // prints 6
cout << f2(4,2) << endl; // prints 2
cout << f3(4,2) << endl; // prints 8
我们可以很容易地使用function类模版和map容器建立一个函数表（function table：容器，通常是map或vector，包含可以调用的值，如函数。）：
Code:
// table of callable objects corresponding to each binary operator
// all the callables must take two ints and return an int
// an element can be a function pointer, function object, or lambda
map<string, function<int(int, int)>> binops;
我们可以将每个可调用对象（无论是函数指针，lambda还是函数对象）添加到此map：
Code:
map<string, function<int(int, int)>> binops = {
{"+", add}, // function pointer
{"-", std::minus<int>()}, // library function object
{"/", div()}, // user-defined function object
{"*", [](int i, int j) { return i * j; }}, // unnamed lambda
{"%", mod} }; // named lambda object
我们的map有五个元素。尽管底层可调用对象的类型彼此不同，但是我们可以将这些不同的类型存储在相同的function<int(int, int)>类型中。
像往常一样，当我们索引map时，我们得到对相关值的引用。当我们索引binops时，我们得到一个类型为function的对象的引用。函数类型会重载调用操作符。该调用运算符获取自己的参数并将它们传递给其存储的可调用对象：
Code:
binops["+"](10, 5); // calls add(10, 5)
binops["-"](10, 5); // uses the call operator of the minus<int> object
binops["/"](10, 5); // uses the call operator of the div object
binops["*"](10, 5); // calls the lambda function object
binops["%"](10, 5); // calls the lambda function object
这里我们调用存储在binops中的每个操作。在第一次调用中，我们返回的元素包含一个指向我们的add函数的函数指针。调用binops["+"](10, 5)实际上是使用该指针调用add，并将10和5传递给它。在下一个调用中binops["-"]，将返回一个存储类型为std::minus<int>的函数。我们称之为对象的调用操作符，依此类推。
我们不能（直接）将重载函数的名称存储在function类型的对象中：
Code:
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} ); // error: which add?
解决歧义的一种方法是存储函数指针而不是函数的名称：
Code:
int (*fp)(int,int) = add; // pointer to the version of add that takes two ints
binops.insert( {"+", fp} ); // ok: fp points to the right version of add
或者，我们可以使用lambda消除歧义：
Code:
// ok: use a lambda to disambiguate which version of add we want to use
binops.insert( {"+", [](int a, int b) {return add(a, b);} } );
lambda主体内部的调用传递两个int。该调用只能与接受两个int的add版本匹配，因此这是在执行lambda时调用的函数。
新库中的function类与名为unary_function和binary_function的类无关，这些类是早期版本的库的一部分。这些类已被更通用的bind函数弃用。
关于function类模板的更多信息可参考std::function。
explicit转换运算符
在实践中，类很少提供转换运算符。实际上编译器为我们提供的自动转换很容易产生意想不到的结果。而在实际工作中，类定义到bool的转换并不少见。
在早期版本中，想要定义到bool的转换的类面临一个问题：因为bool是算术类型，所以转换为bool的类类型对象可以在任何需要算术类型的上下文中使用。这种转换可能以令人惊讶的方式发生。特别是，如果istream有一个到bool类型的转换，则以下代码将成功编译：
Code:
int i = 42;
cin << i; // this code would be legal if the conversion to bool were not explicit!
该程序尝试在输入流上使用输出运算符。没有<<为istream定义，因此该代码几乎可以肯定是错误的。但是，此代码可以使用bool转换运算符将cin转换为bool。然后，生成的bool值将提升为int，并用作内置版本的左移运算符的左侧操作数。提升的bool值（1或0）将向左移位42个位置。
为防止此类问题，新标准引入了explicit转换运算符：
Code:
class SmallInt {
public:
// the compiler won't automatically apply this conversion
explicit operator int() const { return val; }
// other members as before
};
与explicit构造函数一样，编译器不会使用explicit转换运算符进行隐式转换：
Code:
SmallInt si = 3; // ok: the SmallInt constructor is not explicit
si + 3; // error: implicit is conversion required, but operator int is explicit
static_cast<int>(si) + 3; // ok: explicitly request the conversion
如果转换运算符是explicit的，我们仍然可以进行转换。但是，我们必须通过一个强制转换来显式地这样做。
例外情况是编译器将对用作条件的表达式应用显式转换。也就是说，将隐式使用显式转换来转换用作：
-
if，while或do语句的条件。 -
for语句头中的条件表达式。 - 逻辑NOT(
!)，OR(||)或AND(&&)运算符的操作数。 - 条件(
?:)运算符中的条件表达式
在早期版本的库中，IO类型定义了转换为void *。他们这样做是为了避免上述各种问题。在新标准下，IO库定义了对bool的explicit转换。
每当我们在条件中使用流对象时，我们使用为IO类型定义的运算符bool。 例如：
Code:
while (std::cin >> value)
while中的条件执行输入操作符，该操作符读入值并返回cin。为了评估条件，cin由istream operator bool转换函数隐式转换。如果cin的条件状态为good，则该函数返回true，否则返回false。
注：转换为bool通常用于条件。因此，operator bool通常应该被定义为explicit。
参考文献
[1] Lippman S B , Josée Lajoie, Moo B E . C++ Primer (5th Edition)[J]. 2013.
