文章标题

如果构造函数只接受一个实参，则它实际上定义了转换为此类类型的隐式转换机制，有时我们把这种构造函数称作转换构造函数（converting constructor）.

在Sales_data类中，接受string的构造函数和接受istream的构造函数分别定义了从这两种类型向Sales_data隐式转换的规则。也就是说，在需要使用Sales_data的地方，我们可以使用string或istream作为代替：

string null_book = '9-999-99999-9";
//构造一个临时的Sales_data对象
//该对象的units_sold和revenue等于0，，bookNo等于null_book
item.combine(null_book);

编译器用给定的string自动创建了一个Sales_data对象。新生成的这个（临时）Sales_data对象传递给combine。应为combine的参数是一个常量引用，所以我们可以给该参数传递一个临时量。

只允许一步类类型转换

//错误
//字符串转换成string，再string转换成类型
item.combine("9-999-99999-9")；

如果我们想完成上述调用，可以显式的把字符串转换成string或者Sales_data对象

//正确：显式的转成string，隐式的转换成Sales_data
item.combine(string("9-999-99999-9"))；
//正确，隐式的转成成string，显式的转成Sales_data
item.combine(Sales_data("9-999-99999-9"));

抑制构造函数定义的隐式转换

在要求隐式转换的程序上下文中，我们可以通过将构造函数声明为explicit加以阻止

class Sales_data{
Sales_data() = default;
Sales_data(const std::string &s, unsigned n, double p): bookNo(s), units_sold(n), revenue(p*n){}
explict Sales_data(const std::string &s): bookNo(s){}
explict Sales_data(std::istream&);
};

此时，没有任何构造函数能用于隐式地创建Sales_data对象，之前的两种用法都无法通过编译：

item.combine(null_book); //错误，string构造函数是explicit

item.combine(cin); //错误，istream构造函数是explicit

关键字explicit只对一个实参的构造函数有效。需要多个实参的构造函数不能用于执行，所以无需将这些构造函数指定为explicit的。

explicit构造函数只能用于直接初始化

发生隐式转换的一种情况是当我们执行拷贝形式的初始化时（使用=）。此时，我们只能使用直接初始化而不能使用explicit构造函数。

Sales_data item1(null_book);       //正确，直接初始化
//错误，不能将explicit构造函数用于拷贝形式的初始化过程
Sales_data item2 = null_book;

当我们用explicit关键字声明构造函数时，它将只能以直接初始化的形式使用。而且，编译器将不会在自动转换过程中使用该构造函数。

如果没有用explicit的话，item2将会这样被初始化

Sales_data tmp(null_book);再拷贝初始化item2 = tmp;

下面的例子

class String{
explicit String(int n);
String(const char *p);
};
String s1 = 'a'; //错误：不能做隐式char->String转换
String s2(10);   //可以：调用explicit String(int n);
String s3 = String(10);//可以：调用explicit String(int n);再调用默认的复制构造函数
String s4 = "Brian"; //可以：隐式转换调用String(const char *p);再调用默认的复制构造函数
String s5("Fawlty"); //可以：正常调用String(const char *p);
void f(String);
String g()
{
f(10); //错误：不能做隐式int->String转换
f("Arthur"); //可以：隐式转换，等价于f(String("Arthur"));
return 10; //同上
}