1. 隱式型別轉換規則

編譯器的預設隱式型別轉換規則：

先看個例子：

short s = 'a';
unsigned int ui = 1000;
int i = -2000;
double d = i;

//自己先想一下輸出結果，會是什麼
cout << "d = " << d << endl;
cout << "ui + i = " << ui + i << endl;
cout << "sizeof(s + 'b') = " << sizeof(s + 'b') <<endl;

編譯執行結果：

d = -2000
ui + i = 1000
sizeof(s + 'b') = 4

為什麼會是這樣？？？ 為什麼不是 ui + i = -1000
因為編譯器做了隱式型別轉換。
看明白了嗎？那想必你也就明白了為什麼sizeof(s + ‘b’) = 4 了吧。

2. 轉換建構函式:

構成：（1）、首先是一個類的建構函式
（2）、有且僅有一個引數
（3）、引數型別是 基本型別 或者 其他類型別
轉換：
相當於C語言風格中的隱式型別轉換，比如：
int i = 1.5; //就是隱式轉化成了i = (int)1
所以這裡的類Test t = 100; // 就是t = Test(100);

#include <iostream>
 

#include <string>

using namespace std;

class Test
{
    int mValue;
public:
    Test()
    {
        mValue = 0;
    }

    Test(int i)   // 轉換建構函式
    {
        mValue = i;
    }

    Test operator + (const Test& p)
    {
        Test ret(mValue + p.mValue);

        return ret;
    }

    int
 
 value()
    {
        return mValue;
    }
};

int main()
{   
    Test t;
    t = 5;    // t = Test(5);

    Test r;

    r = t + 10;   // r = t + Test(10);
    cout << "r.value() = " << r.value() << endl;

    return 0;
}

猜一下能編譯通過嗎？如果能通過，執行結果是多少？
編譯執行結果：

r.value() = 15

為了避免隱式轉換帶來bug，所以在專案中通常使用關鍵字explicit杜絕編譯器的隱式轉化，轉換建構函式被explicit修飾時只能進行顯示轉換。

3. 型別轉換函式

現在我們來想一個問題， 一個基礎資料型別 和 類型別 之間能不能進行相互轉換？兩個類型別之間能不能進行相互轉換？
示例1：

#include <iostream>
#include <string>

using namespace std;

class Test
{
    int mValue;
public:
    Test(int i = 0)
    {
        mValue = i;
    }
    int value()
    {
        return mValue;
    }
    operator int ()  // 過載int型別轉換函式
    {
        return mValue;
    }
};

int main()
{   
    Test t(100);
    int i = t;   // 把一個類型別賦值給一個int型別

    cout << "t.value() = " << t.value() << endl;
    cout << "i = " << i << endl;

    return 0;
}

示例2：

#include <iostream>
#include <string>

using namespace std;

class Test;

class Value
{
public:
    Value()
    {
    }
    explicit Value(Test& t)  // 有explicit關鍵字修飾的轉換建構函式，使用時需要顯式呼叫
    {
    }
};

class Test
{
    int mValue;
public:
    Test(int i = 0)
    {
        mValue = i;
    }
    int value()
    {
        return mValue;
    }
    operator Value() // 過載Value類型別
    {
        Value ret;
        cout << "operator Value()" << endl;
        return ret;
    }
};

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

    return 0;
}

因為無法抑制隱式的型別轉換函式呼叫，或者型別轉換函式可能與轉換建構函式衝突，所以在專案中通常使用Type toType()的共有成員函式代替型別轉換函式。