對于類型轉(zhuǎn)換函數(shù)（convert function），共有兩種形式：

1. 當(dāng)前類轉(zhuǎn)換成其他類
2. 其他類轉(zhuǎn)換成當(dāng)前類

當(dāng)前類轉(zhuǎn)換成其他類

語法：
operator <typename>() const {...}
語法特點(diǎn)：

1. 沒有返回值
2. 沒有參數(shù)
3. 不改變類的數(shù)據(jù)成員（const），因?yàn)槭寝D(zhuǎn)換。

class Fraction{
    public:
        //non-explicit-one-argument ctor 可以把int類型轉(zhuǎn)換成該類類型實(shí)例
        Fraction(int num, int den = 1) : m_numerator(num), m_denominator(den) { }
        //轉(zhuǎn)換函數(shù)，可以轉(zhuǎn)成double
        operator double() const {
            return (double) (m_numerator / m_denominator);
        }
    private:
        int m_numerator; //分子
        int m_denominator; // 分母
};

//調(diào)用
Fraction f(3,5);
double d=4+f;       // 編譯器首先會(huì)找全局的函數(shù)operator +(int, Fraction)->沒有
                    // 編譯器再找有沒有可以把Fraction 轉(zhuǎn)換成double的轉(zhuǎn)換函數(shù)
                    // operator double() ->有

其他類轉(zhuǎn)換成當(dāng)前類（non-explicit-one-argument ctor 非明確的單實(shí)參構(gòu)造函數(shù)）

把其他類轉(zhuǎn)換成當(dāng)前類，需要使用non-explicit-one-argument ctor（非明確的單實(shí)參構(gòu)造）函數(shù)來配合實(shí)現(xiàn)。
語法特點(diǎn)：

1. non-explicit
2. 實(shí)參只有一個(gè)（形參可以多個(gè)）的構(gòu)造函數(shù)
3. 一個(gè)引導(dǎo)轉(zhuǎn)換的操作符重載函數(shù)
   例如：

class Fraction{
    public:
        //non-explicit-one-argument ctor 可以把int類型轉(zhuǎn)換成該類類型實(shí)例
        Fraction(int num, int den = 1) : m_numerator(num), m_denominator(den) { }
        //重載+操作符
        Fraction operator +(const Fraction & f)  {
            return Fraction(......);//根據(jù)分?jǐn)?shù)加法規(guī)則構(gòu)造臨時(shí)的Fraction變量并傳值的方式返回
        }
    private:
        int m_numerator; //分子
        int m_denominator; // 分母
};

//調(diào)用
Fraction f(3,5);
double d=f+4;       // 編譯器首先會(huì)找全局的函數(shù)operator +(Fraction,int)->沒有
                    //編譯器再去Fraction的類內(nèi)部找 operator+(int)的操作符重載函數(shù)->沒有
                    // 編譯器再找有沒有可以把int轉(zhuǎn)換成Fraction的轉(zhuǎn)換函數(shù)->
                    //發(fā)現(xiàn)了non-explicit-one-argument ctor可以把int 轉(zhuǎn)換成Fraction->
                    //然后再調(diào)用operator +(Fraction&) ->有

轉(zhuǎn)換函數(shù) vs non-explicit-one-argument ctor

如果以上兩種方式同時(shí)存在，即Fraction即可以轉(zhuǎn)換成double， 同時(shí)又支持int型數(shù)據(jù)轉(zhuǎn)換成Fraction形式，則：

class Fraction{
    public:
        //non-explicit-one-argument ctor 可以把int類型轉(zhuǎn)換成該類類型實(shí)例
        Fraction(int num, int den = 1) : m_numerator(num), m_denominator(den) { }
        //轉(zhuǎn)換函數(shù)，可以轉(zhuǎn)成double
        operator double() const {
            return (double) (m_numerator / m_denominator);
        }
        //重載+操作符
        Fraction operator +(const Fraction & f)  {
            return Fraction(f.m_numerator, m_denominator);//根據(jù)分?jǐn)?shù)加法規(guī)則構(gòu)造臨時(shí)的Fraction變量
                                                          //并傳值的方式返回
        }
    private:
        int m_numerator; //分子
        int m_denominator; // 分母
};

//調(diào)用
Fraction f(3,5);
Fraction f2 = f + 4;//錯(cuò)誤 ->沖突，既可以把f轉(zhuǎn)換成double，又可以把4轉(zhuǎn)換成Fraction
double d = 4 + f;//正確

Paste_Image.png

explicit-one-argument ctor

對于上面類型轉(zhuǎn)換的沖突，如果把構(gòu)造函數(shù)前面加上explict關(guān)鍵字，就不會(huì)再有沖突。
因?yàn)閑xplict常用語構(gòu)造函數(shù)，表示必須顯示調(diào)用構(gòu)造函數(shù)才可以轉(zhuǎn)換，即上面的例子，4不可以默認(rèn)成Franction（4），如果需要轉(zhuǎn)換必須明確調(diào)用才會(huì)發(fā)生轉(zhuǎn)換。

class Fraction{
    public:
        //explicit-one-argument ctor 不可以把int類型轉(zhuǎn)換成該類類型實(shí)例
        explict Fraction(int num, int den = 1) : m_numerator(num), m_denominator(den) { }
        //轉(zhuǎn)換函數(shù)，可以轉(zhuǎn)成double
        operator double() const {
            return (double) (m_numerator / m_denominator);
        }
        //重載+操作符
        Fraction operator +(const Fraction & f)  {
            return Fraction(f.m_numerator, m_denominator);//根據(jù)分?jǐn)?shù)加法規(guī)則構(gòu)造臨時(shí)的Fraction變量
                                                          //并傳值的方式返回
        }
    private:
        int m_numerator; //分子
        int m_denominator; // 分母
};

//調(diào)用
Fraction f(3,5);
Fraction f2 = f + 4;//正確 ->不會(huì)把4轉(zhuǎn)換成Fraction（4），只會(huì)把f轉(zhuǎn)換成double
double d = 4 + f;//正確

explicit關(guān)鍵字，一般就用于約束構(gòu)造函數(shù)上（不可以隱式轉(zhuǎn)換）