转换函数与explicit

简介：

转换函数分为两类，一种是转出，把自己转换成别的类型，一种是转入，把别人转成自己类型，当两种都存在时，就可能会有歧义，造成编译器无法识别，这时候就需要explicit关键字。

测试代码：

先看类的结构：

class Fraction {
public:
    Fraction(int num, int den = 1) : m_num(num), m_den(den) {  //转入
        std::cout << "constructor funtion have called" << std::endl;
    }
    operator double() const {  //转出
        std::cout << "operator funtion have called" << std::endl;
        return ((double)m_num / m_den);
    }
    Fraction operator+(const Fraction& f) {
        this->m_num += f.m_num;
        this->m_den += f.m_den;
        return *this;
    }
    void printf() {
        std::cout << m_num << "\t"  << m_den <<std::endl;
    }
private:
    int m_num;
    int m_den;
};

调用类1：

int main() {
    Fraction fun(3, 5);
    double d = fun + 4;
    std::cout << d << std::endl;
    return 0;
}

运行结果如下：

可以看到对象fun调用了重载函数，转换成了double类型。

调用类2：

int main() {
    Fraction fun(3, 5);
    Fraction d = fun + 4;
    d.printf();
    return 0;
}

此时需要注释掉Fraction类的operator double()方法，运行结果如下：

可以看到int类型的4，调用了Fraction的构造函数，转成了Fraction类型；

然后恢复掉Fraction的operator double()方法，编译时就会报错，程序有歧义，把构造函数加上explicit关键字后，就会报错conversion from ‘double’ to non-scalar type ‘Fraction’。