先上一个关于隐式类型转换的例子
struct Rational1 {
Rational1(int n=0, int d=1):num(n), den(d) {
cout << __func__ << "(" << num << "/" << den << ")" << endl;
}
int num;
int den;
};
struct Rational2 {
explicit Rational2(int n=0, int d=1):num(n), den(d) {
cout << __func__ << "(" << num << "/" << den << ")" << endl;
}
int num;
int den;
};
void Display1(Rational1 r1) {
cout << "Numerator: " << r1.num << " Denominator:" << r1.den << endl;
}
void Display2(Rational2 r2) {
cout << "Numerator: " << r2.num << " Denominator:" << r2.den << endl;
}
int main(){
Rational1 r1_1 = 11; // Rational1(11/1)
Rational1 r1_2(12); // Rational1(12/1)
Rational2 r2_1 = 21; // 无法通过编译
Rational2 r2_2(22); // Rational2(22/1)
Display1(1); // Rational1(1/1)
Display2(2); // 无法通过编译
Display2(Rational2(2)); // Rational2(2/1)
return 0;
}
Rational1和Rational2唯一的区别是构造函数的explicit，如果不声明explicit，构造函数会被隐式调用。虽然Display1编译成功了，但是如果不结合Ration1的定义，很容易误会成Display1接受一个整型变量并打印。
在C++11中，标准将explicit的使用范围扩展到了自定义的类型转换操作符上，以支持“显示类型转换”。explicit关键字作用于类型转换操作符，意味着只有在直接构造函数或显示类型转换的时候可以使用该类型。例如：
class ConvertTo {};
class Convertable {
public:
explicit operator ConvertTo() const { return ConvertTo(); }
};
void func(ConvertTo ct) {}
int main(){
Convertable c;
ConvertTo ct(c); //直接初始化，通过
ConvertTo ct2 = c; //拷贝构造函数初始化，编译失败
ConvertTo ct3 = static_cast<ConvertTo>(c); //强制转化，通过
func(c); //拷贝构造初始化，编译失败
return 0;
}
Convertable类中定义了一个显示转换到ConvertTo类型的类型转换符。对于main函数中，ct是通过直接构造函数初始化，可以编译通过，ct3是显示强制转换，编译通过。而ct2是通过拷贝构造函数初始化，编译失败，用函数func时，传入Convertable的变量会导致参数的拷贝构造，编译不通过。
