我們還是以代碼為例來進行分析

#include <iostream>
#include <string>

using namespace std;

int main()
{
    short s = 'a';
    unsigned int ui = 100;
    int i = -200;   // safe
    double d = i;   // safe
    
    cout << "d = " << d << endl;
    cout << "ui = " << ui << endl;
    
    if( (ui + i) > 0 )
    {
        cout << "Positive" << endl;
    }
    else
    {
        cout << "Negative" << endl;
    }
    
    cout << "sizeof(s + 'b') = " << sizeof(s + 'b') << endl;
    
    return 0;
}

我們來試著打印下 d 和 ui 的值，如果 ui + i > 0，則打印 Positive，否則打印 Negative。最後看看 short 和 char 類型會轉換成 short 嗎？看看編譯結果

我們看到打印的是 Positive，也就說 ui + i > 0。根據數學知識，怎麽可能呢？我們一會再來打印下他們相加的值看看，最後一個竟然打印的是 4，short 類型不是 2 嗎？再看看我們上面的隱式類型轉換規則，short 和 char 都會轉換成 int 類型。而 int 也會隱式轉換成 unsigned int，所以結果並不驚奇，我們來看看他們相加的值是多少？

我們看到他們相加是個那麽大的隨機數，這肯定大於 0 啦。那麽在 C++ 中問題來了：普通類型與類類型之間能否進行類型轉換？類類型之間能否進行類型轉換？下來我們來看看示例代碼

#include <iostream>
#include <string>

using namespace std;

class Test
{
    int mValue;
public:
    Test()
    {
        mValue = 0;
    }
    
    Test(int i)
    {
        mValue = i;
    }
    
    Test operator + (const Test& t)
    {
        Test ret(mValue + t.mValue);
        
        return ret;
    }
    
    int value()
    {
        return mValue;
    }
};

int main()
{
    Test t;
    
    t = 5;
    
    cout << "t.value() = " << t.value() << endl;
    
    Test r;
    
    r = t + 10;
    
    cout << "r.value() = " << r.value() << endl;
    
    return 0;
}

我們來看看這樣直接 t = 5，和 r = t + 10；可以通過嗎？看看編譯結果

我們看到編譯通過了，並且也執行成功。下來我們來分析下為什麽會支持這樣的寫法，在構造函數中可以定義不同類型的參數，參數滿足這三個條件時便稱之為轉換構造函數：a> 有且僅有一個參數；b> 參數是基本類型；c> 參數是其它類類型。那麽我們從 C 的角度來看看強制類型轉換：int i = int(1.5)；Test t = Test(100)；這樣便不難解釋了，為了顯示編譯器的強大，編譯器會盡力嘗試讓源碼通過編譯，如下

編譯盡力嘗試的結果便是隱式類型轉換，使用轉換構造函數來進行轉換。但是隱式類型的轉換會讓程序以意想不到的方式進行工作，是工程中的 bug 的重要來源。如果在那塊我們只是手誤寫成那樣了，編譯器卻讓它通過了，我們看到運行結果不對，bug 卻無從查起。。。

所以為了解決這個問題，我們便在工程中通過 explicit 關鍵字來杜絕編譯器的轉換嘗試，轉換構造函數被 explicit 修飾時只能進行顯示轉換，轉換方式是：a> static_cast <ClassName>(value)；b> ClassName(value)；c> (ClassName)value；但是在 C++ 中我們推薦的是第一種寫法，最後一種往往是不推薦的。下來我們就來試試 explicit 關鍵字，在 Test(int i) 成員函數前加上，看看編譯器還會不會進行隱式類型轉換

那麽編譯器直接報錯了，我們再來試試手動的進行類型轉換，我們將第 37 和 43 行改為下面那樣

    t = static_cast<Test>(5);
    
    r = t + static_cast<Test>(10);

我們來看看編譯結果

結果和我們之前的是一樣的。那麽從普通類型能夠轉換到類類型，類類型能否轉換到普通類型呢？我們在 C++ 類中可以定義類型轉換函數，類型轉換函數用於將類對象轉換為其它類型，語法規則如下

下來我們來試試編寫類型轉換函數

#include <iostream>
#include <string>

using namespace std;

class Test
{
    int mValue;
public:
    Test(int i)
    {
        mValue = i;
    }
    
    int value()
    {
        return mValue;
    }
    
    operator int ()
    {
        return mValue;
    }
};

int main()
{
    Test t(100);
    int i = t;
    
    cout << "t.value() = " << t.value() << endl;
    cout << "i = " << i << endl;
    
    return 0;
}

我們來試試看這樣行不行呢，編譯結果如下

我們看到類對象已經成功轉換為普通數據類型。那麽類型轉換函數具有以下幾個特點：a> 與轉換構造函數具有相等的地位；b> 使得編譯器有能力將對象轉化為其它類型；c> 編譯器能夠隱式的使用類型轉換函數。同樣，編譯器也會盡量嘗試讓源碼通過編譯，如下

那麽便不難解釋我們上面的程序了。既然這樣都可以轉換，類類型之間可以相互轉換嗎？我們來看看

#include <iostream>
#include <string>

using namespace std;

class Value
{
public:
    Value()
    {
    }
};

class Test
{
    int mValue;
public:
    Test(int i)
    {
        mValue = i;
    }
    
    int value()
    {
        return mValue;
    }
    
    operator Value ()
    {
        Value ret;
        
        return ret;
    }
};

int main()
{
    Test t(100);
    Value v = t;
    
    return 0;
}

那麽我們看到 Test 和 Value 是兩個不同的類，它們能轉換成功嗎？我們來看看編譯結果

編譯通過，當然沒什麽輸出了，我們在程序中又沒有什麽打印語句。那麽如果我們在類 Value 中加上轉換構造函數呢？編譯器會作何選擇？這時我們的 VAlue 類將會變成

class Value
{
public:
    Value()
    {
    }
    Value(Test& t)
    {
    }
};

我們來編譯下看看結果

編譯器報錯了，它犯難了。這是不知道是調用 Test 類的類型轉換函數還是 Value 類的轉換構造函數了，像這種情況，我們在轉換構造函數前加上 explicit 關鍵字，編譯器便不會去隱式的調用轉換構造函數了。我們在類型轉換函數中加上一句輸出，看看結果

我們可以看出調用的確實是類型轉換函數。那麽我們無法抑制隱式的類型轉換函數調用，類型轉換函數便可能與轉換構造函數造成沖突，工程中以 Type toType() 的共有成員函數代替類型轉換函數。

通過對類型轉換函數的學習，總結如下：1、轉換構造函數只有一個參數；2、轉換構造函數的參數類型是其它類型，它在類型轉換時被調用；3、隱式類型轉換時工程中 bug 的重要來源，explicit 關鍵字用於杜絕隱式類型轉換；4、C++ 類中可以定義類型轉換函數；5類型轉換函數用於將類對象轉換為其它類型，它與轉換構造函數具有同等的地位；6、工程中以 Type toType() 的共有成員函數代替類型轉換函數。

歡迎大家一起來學習 C++ 語言，可以加我QQ：243343083。

類型轉換函數（三十五）