快捷導(dǎo)航

C++11中隱式類型轉(zhuǎn)換的實現(xiàn)示例

更新時間：2024年06月23日 10:48:54 作者：有趣的中國人

C++類型轉(zhuǎn)換分為:隱式類型轉(zhuǎn)換和顯式類型轉(zhuǎn)換,本文主要介紹了C++11中隱式類型轉(zhuǎn)換的實現(xiàn)示例,具有一定的參考價值,感興趣的可以了解一下

1. 關(guān)于C++11

1.1 C++11簡介

在2003年C++標(biāo)準(zhǔn)委員會曾經(jīng)提交了一份技術(shù)勘誤表(簡稱TC1)， 使得 C++03 這個名字已經(jīng)取代了 C++98 成為 C++11 之前的最新C++標(biāo)準(zhǔn)名稱。

不過由于 C++03(TC1) 主要是對 C++98 標(biāo)準(zhǔn)中的漏洞進(jìn)行修復(fù)，語言的核心部分則沒有改動，因此人們習(xí)慣性的把兩個標(biāo)準(zhǔn)合并稱為 C++98/03 標(biāo)準(zhǔn)。從 C++0x 到C++11，C++ 標(biāo)準(zhǔn)10年磨一劍，第二個真正意義上的標(biāo)準(zhǔn)珊珊來遲。

相比于 C++98/03，C++11 則帶來了數(shù)量可觀的變化，其中包含了約 140 個新特性，以及對 C++03 標(biāo)準(zhǔn)中約 600 個缺陷的修正，這使得 C++11 更像是從 C++98/03 中孕育出的一種新語言。相比較而言，C++11 能更好地用于系統(tǒng)開發(fā)和庫開發(fā)、語法更加泛華和簡單化、更加穩(wěn)定和安全，不僅功能更強(qiáng)大，而且能提升程序員的開發(fā)效率，公司實際項目開發(fā)中也用得比較多，所以我們要認(rèn)真去學(xué)習(xí)。

1.2 C++11官方介紹

??官網(wǎng)鏈接： C++11

2. 統(tǒng)一的列表初始化

2.1 C/C++98 數(shù)組 & 結(jié)構(gòu)體初始化

在C/C++98中，標(biāo)準(zhǔn)允許使用花括號 { } 對數(shù)組或者結(jié)構(gòu)體元素進(jìn)行統(tǒng)一的列表初始值設(shè)定。比如：

struct Point
{
	int _x;
	int _y;
};

int main()
{
	// struct Point類型的初始化
	Point p = { 100, 99 };
	int arr1[10] = { 10, 20, 30 };
	return 0;
}

2.2 單/多參數(shù)類型的隱式類型轉(zhuǎn)換

對于自定義類型，如果是單參數(shù)類型的構(gòu)造函數(shù)，會發(fā)生隱式類型轉(zhuǎn)換，例如：

class A
{
public:
	A(int x)
		: _x(x)
		, _y(x)
	{}

	void Print()
	{
		cout << _x << ":" << _y << endl;
	}

private:
	int _x;
	int _y;
};

int main()
{
	// 隱式類型轉(zhuǎn)換
	A aa1 = 1;
	A aa2 = { 2 };
	
	// 直接構(gòu)造
	A aa3(3);
	
	// 也可以省略等號
	A aa4{ 1 };
	return 0;
}

如果是多參數(shù)類型的構(gòu)造函數(shù)，同樣會發(fā)生隱式類型轉(zhuǎn)換，例如：

class A
{
public:
	A(int x, int y)
		: _x(x)
		, _y(y)
	{}
	
private:
	int _x;
	int _y;
};

int main()
{
	// 隱式類型轉(zhuǎn)換
	A aa1 = { 1, 2 };
	
	// 也可以省略等號
	A aa2{ 3, 4 };

	// 可以省略等號
	A aa3(4, 5);

	return 0;
}

如果不想發(fā)生隱式類型的轉(zhuǎn)換，可以在構(gòu)造函數(shù)之前加上 explicit 關(guān)鍵字，例如：

class A
{
public:
	// 不允許發(fā)生隱式類型轉(zhuǎn)換
	explicit A(int x, int y)
		: _x(x)
		, _y(y)
	{}
	
	// 不允許發(fā)生隱式類型轉(zhuǎn)換
	explicit A(int x)
		: _x(x)
		, _y(x)
	{}

	void Print()
	{
		cout << _x << ":" << _y << endl;
	}

private:
	int _x;
	int _y;
};

int main()
{
	// 下面兩行會報錯
	A aa0 = 1;
	A aa3 = { 1 };
	A aa1 = { 1, 2 };
	
	// 以下可以正常使用
	A aa2{ 3, 4 };
	A aa4{ 0 };
	
	return 0;
}

關(guān)于單/多參數(shù)類型的構(gòu)造函數(shù)的解釋：

對于形如 A aa1 = { 1, 2 };的構(gòu)造，編譯器處理時會發(fā)生以下兩個步驟：

首先會利用 { } 中的值調(diào)用構(gòu)造函數(shù)生成一個臨時變量；

對 aa1 進(jìn)行拷貝構(gòu)造。

但是編譯器會優(yōu)化成直接構(gòu)造。

對于形如 A aa2{ 3, 4 };的構(gòu)造，就會直接調(diào)用構(gòu)造函數(shù)，不會產(chǎn)生臨時變量。

如果產(chǎn)生了臨時變量，我們知道臨時變量具有常性，就有：

如果用：A& aa1 = { 1, 2 };會報錯。
得用：const A& aa1 = { 1, 2 };

3. STL 中的 Initializer_list 構(gòu)造函數(shù)

我們這里先以 vector 為例。

3.1 Initializer_list

initializer_list 是 C++11 引入的一種標(biāo)準(zhǔn)庫類型，用于方便地初始化同一種類型的元素列表。initializer_list 允許通過大括號 { } 語法進(jìn)行初始化，例如：

std::initializer_list<int> my_list = {1, 2, 3, 4, 5};

這里 my_list 是一個包含了整數(shù)元素 {1, 2, 3, 4, 5} 的 initializer_list<int> 對象。

主要特點包括：

不可變性： 一旦初始化完成，initializer_list 中的元素不可再被修改。
輕量：initializer_list 本身只包含指向數(shù)據(jù)的指針和長度信息，因此非常輕量，適合在函數(shù)參數(shù)傳遞和對象構(gòu)造時使用。
語法簡潔： 通過 { } 初始化列表的語法，能夠清晰地指定一組初始值，而不需要顯式地調(diào)用構(gòu)造函數(shù)。

底層實現(xiàn)邏輯：

namespace std 
{
    template<class T>
    class initializer_list 
    {
    public:
        using value_type      = T;
        using reference       = const T&;
        using const_reference = const T&;
        using size_type       = size_t;

        initializer_list() noexcept; // 構(gòu)造一個空的 initializer_list
        size_type size() const noexcept; // 返回列表中元素的個數(shù)
        const T* begin() const noexcept; // 返回指向第一個元素的指針
        const T* end() const noexcept; // 返回指向最后一個元素之后的位置的指針
    };
}

3.2 Initializer_list 初始化容器

當(dāng)使用vector時，每次都用不同數(shù)量的值初始化容器，那么就要寫非常多的構(gòu)造函數(shù)來實現(xiàn)這個需求。

但是用Initializer_list就可以一勞永逸的解決這個問題。

int main()
{
	// 用 10 個 1 構(gòu)造 vector
	vector<int> v(10, 1);

	initializer_list<int> il = { 10,9,8,5 };
	vector<int>(il);
	
	vector<int> v1 = { 1,2,3,4,5,6 };
	vector<int> v2({ 9,8,7,6,5,4 });

	return 0;
}

兩種構(gòu)造的區(qū)別：

對于：vector<int> v1 = { 1,2,3,4,5,6 };

編譯器會先將{ 1,2,3,4,5,6 }識別成initializer_list；
然后調(diào)用Initializer_list的構(gòu)造，中間生成臨時變量；
最后拷貝構(gòu)造給v1；
但是編譯器會優(yōu)化成直接構(gòu)造。

對于：vector<int> v2({ 9,8,7,6,5,4 });

這就是直接構(gòu)造。
總的來說，形如：X自定義 = Y類型 一定發(fā)生了隱式類型轉(zhuǎn)換。X 支持 Y 為參數(shù)類型構(gòu)造就可以。

對于 map 的 initializer_list 的構(gòu)造

map 支持 pair 類型的 initializer_list 的構(gòu)造：

在這里插入圖片描述

這里的 value_type 就是 pair。

map構(gòu)造代碼示意：

int main()
{
	// 方法一：
	pair<string, string> kv1 = { "include", "包括" };
	pair<string, string> kv2 = { "sort","排序" };
	map<string, string> dict1({ kv1, kv2 });

	// 方法二：
	map<string, string> dict2 = { kv1, kv2 };
	map<string, string> dict3 = {{"include", "包括"}, { "sort","排序" }};
	
	return 0;
}

兩種構(gòu)造區(qū)別：

對于方法一：

因為pair支持雙參數(shù)的構(gòu)造函數(shù)，所以{ "include", "包括" }、 { "sort","排序" }會發(fā)生隱式類型的轉(zhuǎn)換生成臨時變量，然后再拷貝構(gòu)造給kv1，kv2（編譯器會優(yōu)化成直接構(gòu)造）；
因為map 支持 pair 類型的 initializer_list 的構(gòu)造，因此直接使用：map<string, string> dict1({ kv1, kv2 });即可

對于方法二：