系列文章目錄

前言

一、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)名稱。不過由于TC1主要是對C++98標(biāo)準(zhǔ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)定和安全，不僅功能更強大，而且能提升程序員的開發(fā)效率。

二、 列表初始化(了解)

1.C++98中{}的初始化問題

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

int array1[] = {1,2,3,4,5};int array2[5] = {0};

對于一些自定義的類型，卻無法使用這樣的初始化。比如：

vector v{1,2,3,4,5};

就無法通過編譯，導(dǎo)致每次定義vector時，都需要先把vector定義出來，然后使用循環(huán)對其賦初始值，非常不方便。C++11擴大了用大括號括起的列表(初始化列表)的使用范圍，使其可用于所有的內(nèi)置類型和用戶自定義的類型，使用初始化列表時，可添加等號(=)，也可不添加。

2.內(nèi)置類型的列表初始化

int main(){	// 內(nèi)置類型變量	int x1 = { 10 };	int x2{ 10 };	int x3 = 1 + 2;	int x4 = { 1 + 2 };	int x5{ 1 + 2 };	// 數(shù)組	int arr1[5] {1, 2, 3, 4, 5};	int arr2[]{1, 2, 3, 4, 5};	// 動態(tài)數(shù)組，在C++98中不支持	int* arr3 = new int[5]{1, 2, 3, 4, 5};	// 標(biāo)準(zhǔn)容器	vector<int> v{ 1, 2, 3, 4, 5 };	map<int, int> m{ { 1, 1 }, { 2, 2, }, { 3, 3 }, { 4, 4 } };	return 0;}

注意：列表初始化可以在{}之前使用等號，其效果與不使用=沒有什么區(qū)別。

3.自定義類型的列表初始化

標(biāo)準(zhǔn)庫支持單個對象的列表初始化。

class Point{public:	Point(int x = 0, int y = 0) : _x(x), _y(y)	{}private:	int _x;	int _y;};int main(){	Pointer p{ 1, 2 };	return 0;}

多個對象的列表初始化：

多個對象想要支持列表初始化，需給該類(模板類)添加一個帶有initializer_list類型參數(shù)的構(gòu)造函數(shù)即可。注意：initializer_list是系統(tǒng)自定義的類模板，該類模板中主要有三個方法：begin()、end()迭代器以及獲取區(qū)間中元素個數(shù)的方法size()。

#include template<class T>class Vector {public:	// ...	Vector(initializer_list<T> l) : _capacity(l.size()), _size(0)	{		_array = new T[_capacity];		for (auto e : l)			_array[_size++] = e;	}	Vector<T>& operator=(initializer_list<T> l) {		delete[] _array;		size_t i = 0;		for (auto e : l)			_array[i++] = e;		return *this;	}	// ...private:	T* _array;	size_t _capacity;	size_t _size;};

三、變量類型推導(dǎo)(了解)

1.為什么需要類型推導(dǎo)

在定義變量時，必須先給出變量的實際類型，編譯器才允許定義，但有些情況下可能不知道需要實際類型怎么給，或者類型寫起來特別復(fù)雜，比如：

#include #include int main(){	short a = 32670;	short b = 32670;	// c如果給成short，會造成數(shù)據(jù)丟失，如果能夠讓編譯器根據(jù)a+b的結(jié)果推導(dǎo)c的實際類型，就不會存在問題	short c = a + b;	std::map<std::string, std::string> m{ { "apple", "蘋果" }, { "banana", "香蕉" } };	// 使用迭代器遍歷容器, 迭代器類型太繁瑣	std::map<std::string, std::string>::iterator it = m.begin();	while (it != m.end())	{		cout << it->first << " " << it->second << endl;		++it;	}	return 0;}

C++11中，可以使用auto來根據(jù)變量初始化表達式類型推導(dǎo)變量的實際類型，可以給程序的書寫提供許多方便。將程序中c與it的類型換成auto，程序可以通過編譯，而且更加簡潔。關(guān)于auto的詳細介紹可以參考前面的博客。

2. decltype類型推導(dǎo)

1.為什么需要decltype

auto使用的前提是：必須要對auto聲明的類型進行初始化，否則編譯器無法推導(dǎo)出auto的實際類型。但有時候可能需要根據(jù)表達式運行完成之后結(jié)果的類型進行推導(dǎo)，因為編譯期間，代碼不會運行，此時auto也就無能為力。

template<class T1, class T2>T1 Add(const T1& left, const T2& right){   	return left + right;}

如果能用加完之后結(jié)果的實際類型作為函數(shù)的返回值類型就不會出錯，但這需要程序運行完才能知道結(jié)果的實際類型，即RTTI(Run-Time Type Identification 運行時類型識別）。

C++98中確實已經(jīng)支持RTTI：

• typeid只能查看類型名字不能用其結(jié)果類定義類型。
• dynamic_cast只能應(yīng)用于含有虛函數(shù)的繼承體系中。

運行時類型識別的缺陷是降低程序運行的效率。

2. decltype

decltype是根據(jù)表達式的實際類型推演出定義變量時所用的類型，比如：

• 推演表達式類型作為變量的定義類型。

int main(){	int a = 10;	int b = 20;	// 用decltype推演a+b的實際類型，作為定義c的類型	decltype(a + b) c;	cout << typeid(c).name() << endl;	return 0;}

• 推演函數(shù)返回值的類型：

void* GetMemory(size_t size){	return malloc(size);}int main(){	// 如果沒有帶參數(shù)，推導(dǎo)函數(shù)的類型	cout << typeid(decltype(GetMemory)).name() << endl;	// 如果帶參數(shù)列表，推導(dǎo)的是函數(shù)返回值的類型,注意：此處只是推演，不會執(zhí)行函數(shù)	cout << typeid(decltype(GetMemory(0))).name() << endl;	return 0;}

四、范圍for循環(huán)

參考前面博客：C++入門

五、final與override

六、智能指針

后續(xù)文章講解。

七、新增加容器—靜態(tài)數(shù)組array、forward_list以及unordered系列

八、默認成員函數(shù)控制(了解)

在C++中對于空類編譯器會生成一些默認的成員函數(shù)，比如：構(gòu)造函數(shù)、拷貝構(gòu)造函數(shù)、運算符重載、析構(gòu)函數(shù)和&和const&的重載、移動構(gòu)造、移動拷貝構(gòu)造等函數(shù)。如果在類中顯式定義了，編譯器將不會重新生成默認版本。有時候這樣的規(guī)則可能被忘記，最常見的是聲明了帶參數(shù)的構(gòu)造函數(shù)，必要時則需要定義不帶參數(shù)的版本以實例化無參的對象。而且有時編譯器會生成，有時又不生成，容易造成混亂，于是C++11讓程序員可以控制是否需要編譯器生成。

1.顯式缺省函數(shù)

在C++11中，可以在默認函數(shù)定義或者聲明時加上=default，從而顯式的指示編譯器生成該函數(shù)的默認版本，用=default修飾的函數(shù)稱為顯式缺省函數(shù)。

class A{public:	A(int a) : _a(a)	{}	// 顯式缺省構(gòu)造函數(shù)，由編譯器生成,一定生成	A() = default;	// 在類中聲明，在類外定義時讓編譯器生成默認賦值運算符重載	A& operator=(const A& a);private:	int _a;};A& A::operator=(const A& a) = default;int main(){	A a1(10);	A a2;	a2 = a1;	return 0;}

2.刪除默認函數(shù)

如果能想要限制某些默認函數(shù)的生成，在C++98中，是該函數(shù)設(shè)置成private，并且不給定義，這樣只要其他人想要調(diào)用就會報錯。在C++11中更簡單，只需在該函數(shù)聲明加上=delete即可，該語法指示編譯器不生成對應(yīng)函數(shù)的默認版本，稱=delete修飾的函數(shù)為刪除函數(shù)。

class A{public:	A(int a) : _a(a)	{}	// 禁止編譯器生成默認的拷貝構(gòu)造函數(shù)以及賦值運算符重載	A(const A&) = delete;	A& operator(const A&) = delete;private:	int _a;};int main(){	A a1(10);	// 編譯失敗，因為該類沒有拷貝構(gòu)造函數(shù)	//A a2(a1);	// 編譯失敗，因為該類沒有賦值運算符重載	A a3(20);	a3 = a2;	return 0;}

九、右值引用(熟悉)

1.右值引用概念

C++98中提出了引用的概念，引用即別名，引用變量與其引用實體公共同一塊內(nèi)存空間，而引用的底層是通過指針來實現(xiàn)的，因此使用引用，可以提高程序的可讀性。

#define _CRT_SECURE_NO_WARNINGS   1#includeusing namespace std;void Swap(int& left, int & right){	int tmp = left;	left = right;	right = tmp;}

為了提高程序運行效率，C++11中引入了右值引用，右值引用也是別名，但其只能對右值引用。

int add(int a, int b){	return a + b;}int main(){	int a = 10;	int b = 20;	Swap(a, b);	const int&& ra = 10;	// 引用函數(shù)返回值，返回值是一個臨時變量，為右值	int&& rRet = add(10, 20);	return 0;}

為了與C++98中的引用進行區(qū)分，C++11將該種方式稱之為右值引用。

2.左值與右值

左值與右值是C語言中的概念，但C標(biāo)準(zhǔn)并沒有給出嚴格的區(qū)分方式，一般認為：可以放在=左邊的，或者能夠取地址的稱為左值，只能放在=右邊的，或者不能取地址的稱為右值，但是也不一定完全正確。

#define _CRT_SECURE_NO_WARNINGS   1#includeusing namespace std;int main(){	int x = 1;	int y = 2;	//左值引用的定義	int a = 0;	int &b = a;	//左值引用不能引用右值，但const左值引用可以	//int& e = 10;	//int& f = x + y;	const int& e = 10;	const int& f = x + y;	//右值引用的定義	int&& c = 10;	int&& d = x + y;	//右值引用不能引用左值，但是可以引用move后左值	//int&& m = a;	int&& m = move(a);		return 0;}

• 因此關(guān)于左值與右值的區(qū)分不是很好區(qū)分，一般認為：
• 普通類型的變量，因為有名字，可以取地址，都認為是左值。
• const修飾的常量，不可修改，只讀類型的，理論應(yīng)該按照右值對待，但因為其可以取地址(如果只是const類型常量的定義，編譯器不給其開辟空間，如果對該常量取地址時，編譯器才為其開辟空間)，C++11認為其是左值。
• 如果表達式的運行結(jié)果是一個臨時變量或者對象，認為是右值。
• 如果表達式運行結(jié)果或單個變量是一個引用則認為是左值。
• 總結(jié)：
• 不能簡單地通過能否放在=左側(cè)右側(cè)或者取地址來判斷左值或者右值，要根據(jù)表達式結(jié)果或變量的性質(zhì)判斷，比如上述：c常量。
• 能得到引用的表達式一定能夠作為引用，否則就用常引用。
• C++11對右值進行了嚴格的區(qū)分：：
• C語言中的純右值，比如：a+b, 100。
• 將亡值。比如：表達式的中間結(jié)果、函數(shù)按照值的方式進行返回。

3.引用與右值引用比較

在C++98中的普通引用與const引用在引用實體上的區(qū)別：

int main(){	// 普通類型引用只能引用左值，不能引用右值	int a = 10;	int& ra1 = a; // ra為a的別名	//int& ra2 = 10; // 編譯失敗，因為10是右值	const int& ra3 = 10;	const int& ra4 = a;	return 0;}

注意： 普通引用只能引用左值，不能引用右值，const引用既可引用左值，也可引用右值。

C++11中右值引用：只能引用右值，一般情況不能直接引用左值。

int main(){	// 10純右值，本來只是一個符號，沒有具體的空間，	// 右值引用變量r1在定義過程中，編譯器產(chǎn)生了一個臨時變量，r1實際引用的是臨時變量	int&& r1 = 10;	r1 = 100;	int a = 10;	int&& r2 = a; // 編譯失?。河抑狄貌荒芤米笾?/span>	return 0;}

問題：既然C++98中的const類型引用左值和右值都可以引用，那為什么C++11還要復(fù)雜的提出右值引用呢？

4.值的形式返回對象的缺陷

如果一個類中涉及到資源管理，用戶必須顯式提供拷貝構(gòu)造、賦值運算符重載以及析構(gòu)函數(shù)，否則編譯器將會自動生成一個默認的，如果遇到拷貝對象或者對象之間相互賦值，就會出錯，比如：

#define _CRT_SECURE_NO_WARNINGS   1#include#includenamespace yyw{	class string	{		string(const char* str = "")		:_str(new char[strlen(str)+1])		{			strcpy(_str, str);		}		//s2(s1)		string(const string& s)			:_str(new char[strlen(s._str)+1])		{			strcpy(_str, s._str);		}		//s2=s1		string& operator=(const string& s)		{			if (this != &s)			{				char* _Pstr = new char[strlen(s._str) + 1];				strcpy(_Pstr, s._str);				delete[] _str;				_str = _Pstr;			}			return *this;		}		~string()		{			delete[]_str;			_str=nullptr;		}	private:		char* _str;	};}

上述代碼看起來沒有什么問題，但是有一個不太盡人意的地方：

在operator+中：strRet在按照值返回時，必須創(chuàng)建一個臨時對象，臨時對象創(chuàng)建好之后，strRet就被銷毀了，最后使用返回的臨時對象構(gòu)造s3，s3構(gòu)造好之后，臨時對象就被銷毀了。仔細觀察會發(fā)現(xiàn)：strRet、臨時對象、s3每個對象創(chuàng)建后，都有自己獨立的空間，而空間中存放內(nèi)容也都相同，相當(dāng)于創(chuàng)建了三個內(nèi)容完全相同的對象，對于空間是一種浪費，程序的效率也會降低，而且臨時對象確實作用不是很大，那能否對該種情況進行優(yōu)化呢。

5.移動語義

C++11提出了移動語義概念，即：將一個對象中資源移動到另一個對象中的方式，可以有效緩解該問題。

在C++11中如果需要實現(xiàn)移動語義，必須使用右值引用。上述String類增加移動構(gòu)造：

因為strRet對象的生命周期在創(chuàng)建好臨時對象后就結(jié)束了，即將亡值，C++11認為其為右值，在用strRet構(gòu)造臨時對象時，就會采用移動構(gòu)造，即將strRet中資源轉(zhuǎn)移到臨時對象中。而臨時對象也是右值，因此在用臨時對象構(gòu)造s3時，也采用移動構(gòu)造，將臨時對象中資源轉(zhuǎn)移到s3中，整個過程，只需要創(chuàng)建一塊堆內(nèi)存即可，既省了空間，又大大提高程序運行的效率。

注意：

1. 移動構(gòu)造函數(shù)的參數(shù)千萬不能設(shè)置成const類型的右值引用，因為資源無法轉(zhuǎn)移而導(dǎo)致移動語義失效。
2. 在C++11中，編譯器會為類默認生成一個移動構(gòu)造，該移動構(gòu)造為淺拷貝，因此當(dāng)類中涉及到資源管理
   時，用戶必須顯式定義自己的移動構(gòu)造。
   

6.右值引用引用左值

按照語法，右值引用只能引用右值，但右值引用一定不能引用左值嗎？因為：有些場景下，可能真的需要用右值去引用左值實現(xiàn)移動語義。當(dāng)需要用右值引用引用一個左值時，可以通過move函數(shù)將左值轉(zhuǎn)化為右值。C++11中，std::move()函數(shù)位于 頭文件中，該函數(shù)名字具有迷惑性，它并不搬移任何東西，唯一的功能就是將一個左值強制轉(zhuǎn)化為右值引用，然后實現(xiàn)移動語義。

int main(){	String s1("hello world");	String s2(move(s1));	String s3(s2);	return 0;}

注意：以上代碼是move函數(shù)的經(jīng)典的誤用，因為move將s1轉(zhuǎn)化為右值后，在實現(xiàn)s2的拷貝時就會使用移動構(gòu)造，此時s1的資源就被轉(zhuǎn)移到s2中，s1就成為了無效的字符串。