深入理解C++11 3.4 显示转换操作符

先上一个关于隐式类型转换的例子

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的变量会导致参数的拷贝构造，编译不通过。