Conversion function and explicit

brief introduction ：

Conversion functions fall into two categories , One is transfer out , Transform yourself into another type , One is transfer in , Turn others into your own type , When both exist , There may be ambiguity , The compiler cannot recognize , It's time to explicit keyword .

Test code ：

First look at the structure of the class ：

class Fraction {
public:
    Fraction(int num, int den = 1) : m_num(num), m_den(den) {  // into 
        std::cout << "constructor funtion have called" << std::endl;
    }
    operator double() const {  // Transfer out 
        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;
};

Calling class 1：

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

The operation results are as follows ：

You can see objects fun Overloaded function called , Transformed into double type .

Calling class 2：

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

You need to comment out Fraction Class operator double() Method , The operation results are as follows ：

You can see int Type of 4, Called Fraction Constructor for , Into the Fraction type ;

Then recover Fraction Of operator double() Method , Errors will be reported at compile time , Ambiguous procedure , Add the constructor explicit The key word , You're going to report a mistake conversion from ‘double’ to non-scalar type ‘Fraction’.