日本综合一区二区|亚洲中文天堂综合|日韩欧美自拍一区|男女精品天堂一区|欧美自拍第6页亚洲成人精品一区|亚洲黄色天堂一区二区成人|超碰91偷拍第一页|日韩av夜夜嗨中文字幕|久久蜜综合视频官网|精美人妻一区二区三区

RELATEED CONSULTING
相關(guān)咨詢
選擇下列產(chǎn)品馬上在線溝通
服務(wù)時(shí)間：8:30-17:00
你可能遇到了下面的問題
關(guān)閉右側(cè)工具欄

新聞中心

這里有您想知道的互聯(lián)網(wǎng)營銷解決方案
C++11新特性，所有知識點(diǎn)都在這了！

 c++程序員面試過程中基本上都會被問到c++11新特性吧，你是怎么回答的呢？

為涪城等地區(qū)用戶提供了全套網(wǎng)頁設(shè)計(jì)制作服務(wù)，及涪城網(wǎng)站建設(shè)行業(yè)解決方案。主營業(yè)務(wù)為成都網(wǎng)站建設(shè)、網(wǎng)站設(shè)計(jì)、涪城網(wǎng)站設(shè)計(jì)，以傳統(tǒng)方式定制建設(shè)網(wǎng)站，并提供域名空間備案等一條龍服務(wù)，秉承以專業(yè)、用心的態(tài)度為用戶提供真誠的服務(wù)。我們深信只要達(dá)到每一位用戶的要求，就會得到認(rèn)可，從而選擇與我們長期合作。這樣，我們也可以走得更遠(yuǎn)！

本文基本上涵蓋了c++11的所有新特性，并有詳細(xì)代碼介紹其用法，對關(guān)鍵知識點(diǎn)做了深入分析，對重要的知識點(diǎn)我單獨(dú)寫了相關(guān)文章并附上了相關(guān)鏈接，我整理了完備的c++新特性腦圖（由于圖片太大，我沒有放在文章里，同學(xué)可以在后臺回復(fù)消息“新特性”，即可下載完整圖片）。

auto & decltype

關(guān)于C++11新特性，最先提到的肯定是類型推導(dǎo)，C++11引入了auto和decltype關(guān)鍵字，使用他們可以在編譯期就推導(dǎo)出變量或者表達(dá)式的類型，方便開發(fā)者編碼也簡化了代碼。

  •  auto：讓編譯器在編譯器就推導(dǎo)出變量的類型，可以通過=右邊的類型推導(dǎo)出變量的類型。
 
 
 
      
  
  
  1. auto a = 10; // 10是int型，可以自動推導(dǎo)出a是int 
    2.
  •  decltype：相對于auto用于推導(dǎo)變量類型，而decltype則用于推導(dǎo)表達(dá)式類型，這里只用于編譯器分析表達(dá)式的類型，表達(dá)式實(shí)際不會進(jìn)行運(yùn)算。 
 
 
 
      
  
  
  1. cont int &i = 1;  
    2.   
  
  
  2. int a = 2;  
    3.   
  
  
  3. decltype(i) b = 2; // b是const int& 
    4.

關(guān)于auto和decltype的詳細(xì)介紹請看：一文吃透C++11中auto和decltype知識點(diǎn)

左值右值

眾所周知C++11新增了右值引用，這里涉及到很多概念：

  •  左值：可以取地址并且有名字的東西就是左值。
  •  右值：不能取地址的沒有名字的東西就是右值。
  •  純右值：運(yùn)算表達(dá)式產(chǎn)生的臨時(shí)變量、不和對象關(guān)聯(lián)的原始字面量、非引用返回的臨時(shí)變量、lambda表達(dá)式等都是純右值。
  •  將亡值：可以理解為即將要銷毀的值。
  •  左值引用：對左值進(jìn)行引用的類型。
  •  右值引用：對右值進(jìn)行引用的類型。
  •  移動語義：轉(zhuǎn)移資源所有權(quán)，類似于轉(zhuǎn)讓或者資源竊取的意思，對于那塊資源，轉(zhuǎn)為自己所擁有，別人不再擁有也不會再使用。
  •  完美轉(zhuǎn)發(fā)：可以寫一個(gè)接受任意實(shí)參的函數(shù)模板，并轉(zhuǎn)發(fā)到其它函數(shù)，目標(biāo)函數(shù)會收到與轉(zhuǎn)發(fā)函數(shù)完全相同的實(shí)參。
  •  返回值優(yōu)化：當(dāng)函數(shù)需要返回一個(gè)對象實(shí)例時(shí)候，就會創(chuàng)建一個(gè)臨時(shí)對象并通過復(fù)制構(gòu)造函數(shù)將目標(biāo)對象復(fù)制到臨時(shí)對象，這里有復(fù)制構(gòu)造函數(shù)和析構(gòu)函數(shù)會被多余的調(diào)用到，有代價(jià)，而通過返回值優(yōu)化，C++標(biāo)準(zhǔn)允許省略調(diào)用這些復(fù)制構(gòu)造函數(shù)。

這里的詳細(xì)介紹請看：左值引用、右值引用、移動語義、完美轉(zhuǎn)發(fā)，你知道的不知道的都在這里

列表初始化

在C++11中可以直接在變量名后面加上初始化列表來進(jìn)行對象的初始化，詳細(xì)介紹一定要看這篇文章：學(xué)會C++11列表初始化

std::function & std::bind & lambda表達(dá)式

c++11新增了std::function、std::bind、lambda表達(dá)式等封裝使函數(shù)調(diào)用更加方便，詳細(xì)介紹請看：搞定c++11新特性std::function和lambda表達(dá)式

模板的改進(jìn)

C++11關(guān)于模板有一些細(xì)節(jié)的改進(jìn)：

  •  模板的右尖括號
  •  模板的別名
  •  函數(shù)模板的默認(rèn)模板參數(shù)

詳細(xì)介紹請看：C++11的模板改進(jìn)

并發(fā)

c++11關(guān)于并發(fā)引入了好多好東西，有：

  •  std::thread相關(guān)
  •  std::mutex相關(guān)
  •  std::lock相關(guān)
  •  std::atomic相關(guān)
  •  std::call_once相關(guān)
  •  volatile相關(guān)
  •  std::condition_variable相關(guān)
  •  std::future相關(guān)
  •  async相關(guān)

詳細(xì)介紹請看：c++11新特性之線程相關(guān)所有知識點(diǎn)

這里也使用c++11來實(shí)現(xiàn)的線程池和定時(shí)器，可以看：

C++線程池的實(shí)現(xiàn)之格式修訂版

C++定時(shí)器的實(shí)現(xiàn)之格式修訂版

智能指針

很多人談到c++，說它特別難，可能有一部分就是因?yàn)閏++的內(nèi)存管理吧，不像java那樣有虛擬機(jī)動態(tài)的管理內(nèi)存，在程序運(yùn)行過程中可能就會出現(xiàn)內(nèi)存泄漏，然而這種問題其實(shí)都可以通過c++11引入的智能指針來解決，相反我還認(rèn)為這種內(nèi)存管理還是c++語言的優(yōu)勢，因?yàn)楸M在掌握。

c++11引入了三種智能指針：

  •  std::shared_ptr
  •  std::weak_ptr
  •  std::unique_ptr

詳細(xì)介紹請看：c++11新特性之智能指針

基于范圍的for循環(huán)

直接看代碼

 
 
 
      
  
  
  1. vector vec;  
    2.   
  
  
  2. for (auto iter = vec.begin(); iter != vec.end(); iter++) { // before c++11  
    3.   
  
  
  3.    cout << *iter << endl;  
    4.   
  
  
  4. }  
    5.   
  
  
  5. for (int i : vec) { // c++11基于范圍的for循環(huán)  
    6.   
  
  
  6. cout << "i" << endl;  
    7.   
  
  
  7. } 
    8.

委托構(gòu)造函數(shù)

委托構(gòu)造函數(shù)允許在同一個(gè)類中一個(gè)構(gòu)造函數(shù)調(diào)用另外一個(gè)構(gòu)造函數(shù)，可以在變量初始化時(shí)簡化操作，通過代碼來感受下委托構(gòu)造函數(shù)的妙處吧：

不使用委托構(gòu)造函數(shù)：

 
 
 
      
  
  
  1. struct A {  
    2.   
  
  
  2.    A(){}  
    3.   
  
  
  3.    A(int a) { aa_ = a; }  
    4.   
  
  
  4.    A(int a, int b) { // 好麻煩  
    5.   
  
  
  5.        aa_ = a;  
    6.   
  
  
  6.        bb_ = b;  
    7.   
  
  
  7.   }  
    8.   
  
  
  8.    A(int a, int b, int c) { // 好麻煩  
    9.   
  
  
  9.        aa_ = a;  
    10.   
  
  
  10.        bb_ = b;  
    11.   
  
  
  11.        cc_ = c;  
    12.   
  
  
  12.   }  
    13.   
  
  
  13.    int a_; 
    14.   
  
  
  14.    int b_;  
    15.   
  
  
  15.    int c_;  
    16.   
  
  
  16. }; 
    17.

使用委托構(gòu)造函數(shù)：

 
 
 
      
  
  
  1. struct A { 
    2.   
  
  
  2.     A(){}  
    3.   
  
  
  3.    A(int a) { aa_ = a; }  
    4.   
  
  
  4.    A(int a, int b) : A(a) { bb_ = b; }  
    5.   
  
  
  5.    A(int a, int b, int c) : A(a, b) { cc_ = c; }  
    6.   
  
  
  6.    int a_;  
    7.   
  
  
  7.    int b_;  
    8.   
  
  
  8.    int c_;  
    9.   
  
  
  9. }; 
    10.

初始化變量是不是方便了許多。

繼承構(gòu)造函數(shù)

繼承構(gòu)造函數(shù)可以讓派生類直接使用基類的構(gòu)造函數(shù)，如果有一個(gè)派生類，我們希望派生類采用和基類一樣的構(gòu)造方式，可以直接使用基類的構(gòu)造函數(shù)，而不是再重新寫一遍構(gòu)造函數(shù)，老規(guī)矩，看代碼：

不使用繼承構(gòu)造函數(shù)：

 
 
 
      
  
  
  1. struct Base {  
    2.   
  
  
  2.    Base() {}  
    3.   
  
  
  3.    Base(int a) { aa_ = a; }  
    4.   
  
  
  4.    Base(int a, int b) : Base(a) { bb_ = b; }  
    5.   
  
  
  5.    Base(int a, int b, int c) : Base(a, b) { cc_ = c; }  
    6.   
  
  
  6.    int a_;  
    7.   
  
  
  7.    int b_;  
    8.   
  
  
  8.    int c_;  
    9.   
  
  
  9. };  
    10.   
  
  
  10. struct Derived : Base {  
    11.   
  
  
  11.    Derived() {}  
    12.   
  
  
  12.    Derived(int a) : Base(a) {} // 好麻煩  
    13.   
  
  
  13.    Derived(int a, int b) : Base(a, b) {} // 好麻煩  
    14.   
  
  
  14.    Derived(int a, int b, int c) : Base(a, b, c) {} // 好麻煩  
    15.   
  
  
  15. };  
    16.   
  
  
  16. int main() {  
    17.   
  
  
  17.    Derived a(1, 2, 3);  
    18.   
  
  
  18.    return 0;  
    19.   
  
  
  19. } 
    20.

使用繼承構(gòu)造函數(shù)：

 
 
 
      
  
  
  1. struct Base {  
    2.   
  
  
  2.    Base() {}  
    3.   
  
  
  3.    Base(int a) { aa_ = a; }  
    4.   
  
  
  4.    Base(int a, int b) : Base(a) { bb_ = b; }  
    5.   
  
  
  5.    Base(int a, int b, int c) : Base(a, b) { cc_ = c; }  
    6.   
  
  
  6.    int a_;  
    7.   
  
  
  7.    int b_;  
    8.   
  
  
  8.    int c_;  
    9.   
  
  
  9. };  
    10.   
  
  
  10. struct Derived : Base {  
    11.   
  
  
  11.    using Base::Base;  
    12.   
  
  
  12. };  
    13.   
  
  
  13. int main() {  
    14.   
  
  
  14.    Derived a(1, 2, 3);  
    15.   
  
  
  15.    return 0; 
    16.   
  
  
  16.  } 
    17.

只需要使用using Base::Base繼承構(gòu)造函數(shù)，就免去了很多重寫代碼的麻煩。

nullptr

nullptr是c++11用來表示空指針新引入的常量值，在c++中如果表示空指針語義時(shí)建議使用nullptr而不要使用NULL，因?yàn)镹ULL本質(zhì)上是個(gè)int型的0，其實(shí)不是個(gè)指針。舉例：

 
 
 
      
  
  
  1. void func(void *ptr) {  
    2.   
  
  
  2.    cout << "func ptr" << endl;  
    3.   
  
  
  3. }  
    4.   
  
  
  4. void func(int i) {  
    5.   
  
  
  5.    cout << "func i" << endl;  
    6.   
  
  
  6. }  
    7.   
  
  
  7. int main() {  
    8.   
  
  
  8.    func(NULL); // 編譯失敗，會產(chǎn)生二義性  
    9.   
  
  
  9.    func(nullptr); // 輸出func ptr  
    10.   
  
  
  10.    return 0;  
    11.   
  
  
  11. } 
    12.

final & override

c++11關(guān)于繼承新增了兩個(gè)關(guān)鍵字，final用于修飾一個(gè)類，表示禁止該類進(jìn)一步派生和虛函數(shù)的進(jìn)一步重載，override用于修飾派生類中的成員函數(shù)，標(biāo)明該函數(shù)重寫了基類函數(shù)，如果一個(gè)函數(shù)聲明了override但父類卻沒有這個(gè)虛函數(shù)，編譯報(bào)錯(cuò)，使用override關(guān)鍵字可以避免開發(fā)者在重寫基類函數(shù)時(shí)無意產(chǎn)生的錯(cuò)誤。

示例代碼1：

 
 
 
      
  
  
  1. struct Base {  
    2.   
  
  
  2.    virtual void func() {  
    3.   
  
  
  3.        cout << "base" << endl;  
    4.   
  
  
  4.   }  
    5.   
  
  
  5. };  
    6.   
  
  
  6. struct Derived : public Base{  
    7.   
  
  
  7.    void func() override { // 確保func被重寫  
    8.   
  
  
  8.        cout << "derived" << endl;  
    9.   
  
  
  9.   }  
    10.   
  
  
  10.    void fu() override { // error，基類沒有fu()，不可以被重寫      
    11.   
  
  
  11.   }  
    12.   
  
  
  12. }; 
    13.

示例代碼2：

 
 
 
      
  
  
  1. struct Base final {  
    2.   
  
  
  2.    virtual void func() {  
    3.   
  
  
  3.        cout << "base" << endl;  
    4.   
  
  
  4.   }  
    5.   
  
  
  5. };  
    6.   
  
  
  6. struct Derived : public Base{ // 編譯失敗，final修飾的類不可以被繼承  
    7.   
  
  
  7.    void func() override {  
    8.   
  
  
  8.        cout << "derived" << endl;  
    9.   
  
  
  9.   }  
    10.   
  
  
  10. }; 
    11.

default

c++11引入default特性，多數(shù)時(shí)候用于聲明構(gòu)造函數(shù)為默認(rèn)構(gòu)造函數(shù)，如果類中有了自定義的構(gòu)造函數(shù)，編譯器就不會隱式生成默認(rèn)構(gòu)造函數(shù)，如下代碼：

 
 
 
      
  
  
  1. struct A {  
    2.   
  
  
  2.    int a;  
    3.   
  
  
  3.    A(int i) { a = i; }  
    4.   
  
  
  4. };  
    5.   
  
  
  5. int main() {  
    6.   
  
  
  6.    A a; // 編譯出錯(cuò)  
    7.   
  
  
  7.    return 0;  
    8.   
  
  
  8. } 
    9.

上面代碼編譯出錯(cuò)，因?yàn)闆]有匹配的構(gòu)造函數(shù)，因?yàn)榫幾g器沒有生成默認(rèn)構(gòu)造函數(shù)，而通過default，程序員只需在函數(shù)聲明后加上“=default;”，就可將該函數(shù)聲明為 defaulted 函數(shù)，編譯器將為顯式聲明的 defaulted 函數(shù)自動生成函數(shù)體，如下：

 
 
 
      
  
  
  1. struct A {  
    2.   
  
  
  2.    A() = default;  
    3.   
  
  
  3.    int a;  
    4.   
  
  
  4.    A(int i) { a = i; }  
    5.   
  
  
  5. };  
    6.   
  
  
  6. int main() {  
    7.   
  
  
  7.    A a;  
    8.   
  
  
  8.    return 0;  
    9.   
  
  
  9. } 
    10.

編譯通過。

delete

c++中，如果開發(fā)人員沒有定義特殊成員函數(shù)，那么編譯器在需要特殊成員函數(shù)時(shí)候會隱式自動生成一個(gè)默認(rèn)的特殊成員函數(shù)，例如拷貝構(gòu)造函數(shù)或者拷貝賦值操作符，如下代碼：

 
 
 
      
  
  
  1. struct A {  
    2.   
  
  
  2.    A() = default;  
    3.   
  
  
  3.    int a;  
    4.   
  
  
  4.    A(int i) { a = i; }  
    5.   
  
  
  5. };  
    6.   
  
  
  6. int main() {  
    7.   
  
  
  7.    A a1;  
    8.   
  
  
  8.    A a2 = a1;  // 正確，調(diào)用編譯器隱式生成的默認(rèn)拷貝構(gòu)造函數(shù)  
    9.   
  
  
  9.    A a3;  
    10.   
  
  
  10.    a3 = a1;  // 正確，調(diào)用編譯器隱式生成的默認(rèn)拷貝賦值操作符  
    11.   
  
  
  11. } 
    12.

而我們有時(shí)候想禁止對象的拷貝與賦值，可以使用delete修飾，如下：

 
 
 
      
  
  
  1. struct A {  
    2.   
  
  
  2.    A() = default;  
    3.   
  
  
  3.    A(const A&) = delete;  
    4.   
  
  
  4.    A& operator=(const A&) = delete;  
    5.   
  
  
  5.    int a;  
    6.   
  
  
  6.    A(int i) { a = i; }  
    7.   
  
  
  7. };  
    8.   
  
  
  8. int main() {  
    9.   
  
  
  9.    A a1;  
    10.   
  
  
  10.    A a2 = a1;  // 錯(cuò)誤，拷貝構(gòu)造函數(shù)被禁用  
    11.   
  
  
  11.    A a3;  
    12.   
  
  
  12.    a3 = a1;  // 錯(cuò)誤，拷貝賦值操作符被禁用  
    13.   
  
  
  13. } 
    14.

delele函數(shù)在c++11中很常用，std::unique_ptr就是通過delete修飾來禁止對象的拷貝的。

explicit

explicit專用于修飾構(gòu)造函數(shù)，表示只能顯式構(gòu)造，不可以被隱式轉(zhuǎn)換，根據(jù)代碼看explicit的作用：

不用explicit：

 
 
 
      
  
  
  1. struct A {  
    2.   
  
  
  2.    A(int value) { // 沒有explicit關(guān)鍵字  
    3.   
  
  
  3.        cout << "value" << endl;  
    4.   
  
  
  4.   }  
    5.   
  
  
  5. };  
    6.   
  
  
  6. int main() {  
    7.   
  
  
  7.    A a = 1; // 可以隱式轉(zhuǎn)換  
    8.   
  
  
  8.    return 0;  
    9.   
  
  
  9. } 
    10.

使用explicit:

 
 
 
      
  
  
  1. struct A {  
    2.   
  
  
  2.    explicit A(int value) {  
    3.   
  
  
  3.        cout << "value" << endl;  
    4.   
  
  
  4.   }  
    5.   
  
  
  5. };  
    6.   
  
  
  6. int main() {  
    7.   
  
  
  7.    A a = 1; // error，不可以隱式轉(zhuǎn)換  
    8.   
  
  
  8.    A aa(2); // ok  
    9.   
  
  
  9.    return 0;  
    10.   
  
  
  10. } 
    11.

const

因?yàn)橐v后面的constexpr，所以這里簡單介紹下const。

const字面意思為只讀，可用于定義變量，表示變量是只讀的，不可以更改，如果更改，編譯期間就會報(bào)錯(cuò)。

主要用法如下：

  1.  用于定義常量，const的修飾的變量不可更改。
 
 
 
      
  
  
  1. const int value = 5; 
    2.

      2.  指針也可以使用const，這里有個(gè)小技巧，從右向左讀，即可知道const究竟修飾的是指針還是指針?biāo)赶虻膬?nèi)容。

 
 
 
      
  
  
  1. char *const ptr; // 指針本身是常量  
    2.   
  
  
  2. const char* ptr; // 指針指向的變量為常量 
    3.

      3.  在函數(shù)參數(shù)中使用const，一般會傳遞類對象時(shí)會傳遞一個(gè)const的引用或者指針，這樣可以避免對象的拷貝，也可以防止對象被修改。

 
 
 
      
  
  
  1. class A{};  
    2.   
  
  
  2. void func(const A& a); 
    3.

      4.  const修飾類的成員變量，表示是成員常量，不能被修改，可以在初始化列表中被賦值。

 
 
 
      
  
  
  1. class A {  
    2.   
  
  
  2. const int value = 5;  
    3.   
  
  
  3. };  
    4.   
  
  
  4. class B {  
    5.   
  
  
  5. const int value;  
    6.   
  
  
  6. B(int v) : value(v){}  
    7.   
  
  
  7. }; 
    8.

      5.  修飾類成員函數(shù)，表示在該函數(shù)內(nèi)不可以修改該類的成員變量。

 
 
 
      
  
  
  1. class A{  
    2.   
  
  
  2. void func() const;  
    3.   
  
  
  3. }; 
    4.

      6.  修飾類對象，類對象只能調(diào)用該對象的const成員函數(shù)。

 
 
 
      
  
  
  1. class A {  
    2.   
  
  
  2. void func() const;  
    3.   
  
  
  3. };  
    4.   
  
  
  4. const A a;  
    5.   
  
  
  5. a.func(); 
    6.

constexpr

constexpr是c++11新引入的關(guān)鍵字，用于編譯時(shí)的常量和常量函數(shù)，這里直接介紹constexpr和const的區(qū)別：

兩者都代表可讀，const只表示read only的語義，只保證了運(yùn)行時(shí)不可以被修改，但它修飾的仍然有可能是個(gè)動態(tài)變量，而constexpr修飾的才是真正的常量，它會在編譯期間就會被計(jì)算出來，整個(gè)運(yùn)行過程中都不可以被改變，constexpr可以用于修飾函數(shù)，這個(gè)函數(shù)的返回值會盡可能在編譯期間被計(jì)算出來當(dāng)作一個(gè)常量，但是如果編譯期間此函數(shù)不能被計(jì)算出來，那它就會當(dāng)作一個(gè)普通函數(shù)被處理。如下代碼：

 
 
 
      
  
  
  1. #include  
    2.   
  
  
  2. using namespace std;  
    3.   
  
  
  3. constexpr int func(int i) {  
    4.   
  
  
  4.    return i + 1;  
    5.   
  
  
  5. }  
    6.   
  
  
  6. int main() { 
    7.   
  
  
  7.    int i = 2;  
    8.   
  
  
  8.    func(i);// 普通函數(shù)  
    9.   
  
  
  9.    func(2);// 編譯期間就會被計(jì)算出來  
    10.   
  
  
  10. } 
    11.

enum class

c++11新增有作用域的枚舉類型，看代碼

不帶作用域的枚舉代碼：

 
 
 
      
  
  
  1. enum AColor {  
    2.   
  
  
  2.    kRed,  
    3.   
  
  
  3.    kGreen,  
    4.   
  
  
  4.    kBlue  
    5.   
  
  
  5. };  
    6.   
  
  
  6. enum BColor {  
    7.   
  
  
  7.    kWhite,  
    8.   
  
  
  8.    kBlack,  
    9.   
  
  
  9.    kYellow  
    10.   
  
  
  10. };  
    11.   
  
  
  11. int main() {  
    12.   
  
  
  12.    if (kRed == kWhite) {  
    13.   
  
  
  13.        cout << "red == white" << endl;  
    14.   
  
  
  14.   }  
    15.   
  
  
  15.    return 0;  
    16.   
  
  
  16. } 
    17.

如上代碼，不帶作用域的枚舉類型可以自動轉(zhuǎn)換成整形，且不同的枚舉可以相互比較，代碼中的紅色居然可以和白色比較，這都是潛在的難以調(diào)試的bug，而這種完全可以通過有作用域的枚舉來規(guī)避。

有作用域的枚舉代碼：

 
 
 
      
  
  
  1. enum class AColor {  
    2.   
  
  
  2.    kRed,  
    3.   
  
  
  3.    kGreen,  
    4.   
  
  
  4.    kBlue  
    5.   
  
  
  5. };  
    6.   
  
  
  6. enum class BColor {  
    7.   
  
  
  7.    kWhite,  
    8.   
  
  
  8.    kBlack,  
    9.   
  
  
  9.    kYellow  
    10.   
  
  
  10. };  
    11.   
  
  
  11. int main() {  
    12.   
  
  
  12.    if (AColor::kRed == BColor::kWhite) { // 編譯失敗  
    13.   
  
  
  13.        cout << "red == white" << endl;  
    14.   
  
  
  14.   }  
    15.   
  
  
  15.    return 0;  
    16.   
  
  
  16. } 
    17.

使用帶有作用域的枚舉類型后，對不同的枚舉進(jìn)行比較會導(dǎo)致編譯失敗，消除潛在bug，同時(shí)帶作用域的枚舉類型可以選擇底層類型，默認(rèn)是int，可以改成char等別的類型。

 
 
 
      
  
  
  1. enum class AColor : char {  
    2.   
  
  
  2.    kRed, 
    3.   
  
  
  3.    kGreen,  
    4.   
  
  
  4.    kBlue 
    5.   
  
  
  5. }; 
    6.

我們平時(shí)編程過程中使用枚舉，一定要使用有作用域的枚舉取代傳統(tǒng)的枚舉。

非受限聯(lián)合體

c++11之前union中數(shù)據(jù)成員的類型不允許有非POD類型，而這個(gè)限制在c++11被取消，允許數(shù)據(jù)成員類型有非POD類型，看代碼：

 
 
 
      
  
  
  1. struct A {  
    2.   
  
  
  2.    int a;  
    3.   
  
  
  3.    int *b;  
    4.   
  
  
  4. };  
    5.   
  
  
  5. union U { 
    6.   
  
  
  6.     A a; // 非POD類型 c++11之前不可以這樣定義聯(lián)合體  
    7.   
  
  
  7.    int b;  
    8.   
  
  
  8. }; 
    9.

對于什么是POD類型，大家可以自行查下資料，大體上可以理解為對象可以直接memcpy的類型。

sizeof

c++11中sizeof可以用的類的數(shù)據(jù)成員上，看代碼：

c++11前：

 
 
 
      
  
  
  1. struct A {  
    2.   
  
  
  2.    int data[10];  
    3.   
  
  
  3.    int a;  
    4.   
  
  
  4. };  
    5.   
  
  
  5. int main() {  
    6.   
  
  
  6.    A a;  
    7.   
  
  
  7.    cout << "size " << sizeof(a.data) << endl;  
    8.   
  
  
  8.    return 0;  
    9.   
  
  
  9. } 
    10.

c++11后：

 
 
 
      
  
  
  1. struct A {  
    2.   
  
  
  2.    int data[10];  
    3.   
  
  
  3.    int a;  
    4.   
  
  
  4. };  
    5.   
  
  
  5. int main() {  
    6.   
  
  
  6.    cout << "size " << sizeof(A::data) << endl;  
    7.   
  
  
  7.    return 0;  
    8.   
  
  
  8. } 
    9.

想知道類中數(shù)據(jù)成員的大小在c++11中是不是方便了許多，而不需要定義一個(gè)對象，在計(jì)算對象的成員大小。

assertion

 
 
 
      
  
  
  1. static_assert(true/false, message); 
    2.

c++11引入static_assert聲明，用于在編譯期間檢查，如果第一個(gè)參數(shù)值為false，則打印message，編譯失敗。

自定義字面量

c++11可以自定義字面量，我們平時(shí)c++中都或多或少使用過chrono中的時(shí)間，例如：

 
 
 
      
  
  
  1. std::this_thread::sleep_for(std::chrono::milliseconds(100)); // 100ms  
    2.   
  
  
  2. std::this_thread::sleep_for(std::chrono::seconds(100)); // 100s 
    3.

其實(shí)沒必要這么麻煩，也可以這么寫：

 
 
 
      
  
  
  1. std::this_thread::sleep_for(100ms); // c++14里可以這么使用，這里只是舉個(gè)自定義字面量使用的例子  
    2.   
  
  
  2. std::this_thread::sleep_for(100s); 
    3.

這就是自定義字面量的使用，示例如下：

 
 
 
      
  
  
  1. struct mytype {  
    2.   
  
  
  2.    unsigned long long value;  
    3.   
  
  
  3. };  
    4.   
  
  
  4. constexpr mytype operator"" _mytype ( unsigned long long n ) {  
    5.   
  
  
  5.    return mytype{n};  
    6.   
  
  
  6. }  
    7.   
  
  
  7. mytype mm = 123_mytype;  
    8.   
  
  
  8. cout << mm.value << endl; 
    9.

關(guān)于自定義字面量，可以看下chrono的源代碼，相信大家會有很大收獲，需要源碼分析chrono的話，可以留言給我。

內(nèi)存對齊

什么是內(nèi)存對齊

理論上計(jì)算機(jī)對于任何變量的訪問都可以從任意位置開始，然而實(shí)際上系統(tǒng)會對這些變量的存放地址有限制，通常將變量首地址設(shè)為某個(gè)數(shù)N的倍數(shù)，這就是內(nèi)存對齊。

為什么要內(nèi)存對齊

  1.  硬件平臺限制，內(nèi)存以字節(jié)為單位，不同硬件平臺不一定支持任何內(nèi)存地址的存取，一般可能以雙字節(jié)、4字節(jié)等為單位存取內(nèi)存，為了保證處理器正確存取數(shù)據(jù)，需要進(jìn)行內(nèi)存對齊。
  2.  提高CPU內(nèi)存訪問速度，一般處理器的內(nèi)存存取粒度都是N的整數(shù)倍，假如訪問N大小的數(shù)據(jù)，沒有進(jìn)行內(nèi)存對齊，有可能就需要兩次訪問才可以讀取出數(shù)據(jù)，而進(jìn)行內(nèi)存對齊可以一次性把數(shù)據(jù)全部讀取出來，提高效率。

在c++11之前如果想創(chuàng)建內(nèi)存對齊需要：

 
 
 
      
  
  
  1. void align_cpp11_before()  
    2.   
  
  
  2. {  
    3.   
  
  
  3.    static char data[sizeof(void *) + sizeof(A)]; 
    4.   
  
  
  4.    const uintptr_t kAlign = sizeof(void *) - 1;  
    5.   
  
  
  5.    char *align_ptr =  
    6.   
  
  
  6.        reinterpret_cast(reinterpret_cast(data + kAlign) & ~kAlign);  
    7.   
  
  
  7.    A *attr = new (align_ptr) A;  
    8.   
  
  
  8. } 
    9.

c++11關(guān)于內(nèi)存對齊新增了一些函數(shù)：

 
 
 
      
  
  
  1. void align_cpp11_after()  
    2.   
  
  
  2. { 
    3.   
  
  
  3.    static std::aligned_storage  
  
  
  4.                                alignof(A)>::type data;  
    5.   
  
  
  5.    A *attr = new (&data) A;  
    6.   
  
  
  6. } 
    7.

還有：alignof()、std::alignment_of()、alignas()，關(guān)于內(nèi)存對齊詳情可以看這篇文章：內(nèi)存對齊之格式修訂版

thread_local

c++11引入thread_local，用thread_local修飾的變量具有thread周期，每一個(gè)線程都擁有并只擁有一個(gè)該變量的獨(dú)立實(shí)例，一般用于需要保證線程安全的函數(shù)中。

 
 
 
      
  
  
  1. #include   
    2.   
  
  
  2. #include   
    3.   
  
  
  3. class A {  
    4.   
  
  
  4.   public:  
    5.   
  
  
  5.    A() {}  
    6.   
  
  
  6.    ~A() {}  
    7.   
  
  
  7.    void test(const std::string &name) {  
    8.   
  
  
  8.        thread_local int count = 0;  
    9.   
  
  
  9.        ++count;  
    10.   
  
  
  10.        std::cout << name << ": " << count << std::endl;  
    11.   
  
  
  11.   }  
    12.   
  
  
  12. }; 
    13.   
  
  
  13. void func(const std::string &name) {  
    14.   
  
  
  14.    A a1;  
    15.   
  
  
  15.    a1.test(name);  
    16.   
  
  
  16.    a1.test(name);  
    17.   
  
  
  17.    A a2;  
    18.   
  
  
  18.    a2.test(name);  
    19.   
  
  
  19.    a2.test(name);  
    20.   
  
  
  20. }  
    21.   
  
  
  21. int main() {  
    22.   
  
  
  22.    std::thread(func, "thread1").join();  
    23.   
  
  
  23.    std::thread(func, "thread2").join();  
    24.   
  
  
  24.    return 0;  
    25.   
  
  
  25. } 
    26.

輸出：

 
 
 
      
  
  
  1. thread1: 1  
    2.   
  
  
  2. thread1: 2  
    3.   
  
  
  3. thread1: 3  
    4.   
  
  
  4. thread1: 4  
    5.   
  
  
  5. thread2: 1  
    6.   
  
  
  6. thread2: 2  
    7.   
  
  
  7. thread2: 3  
    8.   
  
  
  8. thread2: 4 
    9.

驗(yàn)證上述說法，對于一個(gè)線程私有變量，一個(gè)線程擁有且只擁有一個(gè)該實(shí)例，類似于static。

基礎(chǔ)數(shù)值類型

c++11新增了幾種數(shù)據(jù)類型：long long、char16_t、char32_t等

隨機(jī)數(shù)功能

c++11關(guān)于隨機(jī)數(shù)功能則較之前豐富了很多，典型的可以選擇概率分布類型，先看如下代碼：

 
 
 
      
  
  
  1. #include   
    2.   
  
  
  2. #include   
    3.   
  
  
  3. #include   
    4.   
  
  
  4. using namespace std;  
    5.   
  
  
  5. int main() {  
    6.   
  
  
  6.    std::default_random_engine random(time(nullptr));  
    7.   
  
  
  7.    std::uniform_int_distribution int_dis(0, 100); // 整數(shù)均勻分布  
    8.   
  
  
  8.    std::uniform_real_distribution real_dis(0.0, 1.0); // 浮點(diǎn)數(shù)均勻分布  
    9.   
  
  
  9.    for (int i = 0; i < 10; ++i) {  
    10.   
  
  
  10.        cout << int_dis(random) << ' ';  
    11.   
  
  
  11.   }  
    12.   
  
  
  12.    cout << endl;  
    13.   
  
  
  13.    for (int i = 0; i < 10; ++i) {  
    14.   
  
  
  14.        cout << real_dis(random) << ' ';  
    15.   
  
  
  15.   }  
    16.   
  
  
  16.    cout << endl;  
    17.   
  
  
  17.    return 0;  
    18.   
  
  
  18. } 
    19.

輸出：

 
 
 
      
  
  
  1. 38 100 93 7 66 0 68 99 41 7  
    2.   
  
  
  2. 0.232202 0.617716 0.959241 0.970859 0.230406 0.430682 0.477359 0.971858 0.0171148 0.64863 
    3.

代碼中舉例的是整數(shù)均勻分布和浮點(diǎn)數(shù)均勻分布，c++11提供的概率分布類型還有好多，例如伯努利分布、正態(tài)分布等，具體可以見最后的參考資料。

正則表達(dá)式

c++11引入了regex庫更好的支持正則表達(dá)式，見代碼：

 
 
 
      
  
  
  1. #include   
    2.   
  
  
  2. #include   
    3.   
  
  
  3. #include   
    4.   
  
  
  4. #include   
    5.   
  
  
  5. int main() {  
    6.   
  
  
  6.    std::string s = "I know, I'll use2 regular expressions.";  
    7.   
  
  
  7. // 忽略大小寫 
    8.   
  
  
  8.     std::regex self_regex("REGULAR EXPRESSIONS", std::regex_constants::icase);  
    9.   
  
  
  9.    if (std::regex_search(s, self_regex)) {  
    10.   
  
  
  10.        std::cout << "Text contains the phrase 'regular expressions'\n"; 
    11.   
  
  
  11.    }  
    12.   
  
  
  12.    std::regex word_regex("(\\w+)");  // 匹配字母數(shù)字等字符  
    13.   
  
  
  13.    auto words_begin = std::sregex_iterator(s.begin(), s.end(), word_regex);  
    14.   
  
  
  14.    auto words_end = std::sregex_iterator();  
    15.   
  
  
  15.    std::cout << "Found " << std::distance(words_begin, words_end) << " words\n";  
    16.   
  
  
  16.    const int N = 6;  
    17.   
  
  
  17.    std::cout << "Words longer than " << N << " characters:\n";  
    18.   
  
  
  18.    for (std::sregex_iterator i = words_begin; i != words_end; ++i) {  
    19.   
  
  
  19.        std::smatch match = *i;  
    20.   
  
  
  20.        std::string matchmatch_str = match.str();  
    21.   
  
  
  21.        if (match_str.size() > N) { 
    22.   
  
  
  22.             std::cout << " " << match_str << '\n';  
    23.   
  
  
  23.       }  
    24.   
  
  
  24.   }  
    25.   
  
  
  25.    std::regex long_word_regex("(\\w{7,})");  
    26.   
  
  
  26.    // 超過7個(gè)字符的單詞用[]包圍  
    27.   
  
  
  27.    std::string new_s = std::regex_replace(s, long_word_regex, "[$&]");  
    28.   
  
  
  28.    std::cout << new_s << '\n';  
    29.   
  
  
  29. } 
    30.

chrono

c++11關(guān)于時(shí)間引入了chrono庫，源于boost，功能強(qiáng)大，chrono主要有三個(gè)點(diǎn)：

  •  duration
  •  time_point
  •  clocks

duration

std::chrono::duration表示一段時(shí)間，常見的單位有s、ms等，示例代碼：

 
 
 
      
  
  
  1. // 拿休眠一段時(shí)間舉例，這里表示休眠100ms  
    2.   
  
  
  2. std::this_thread::sleep_for(std::chrono::milliseconds(100)); 
    3.

sleep_for里面其實(shí)就是std::chrono::duration，表示一段時(shí)間，實(shí)際是這樣：

 
 
 
      
  
  
  1. typedef duration milliseconds;  
    2.   
  
  
  2. typedef duration seconds; 
    3.

duration具體模板如下：

 
 
 
      
  
  
  1. 1 template  > class duration; 
    2.

Rep表示一種數(shù)值類型，用來表示Period的數(shù)量，比如int、float、double，Period是ratio類型，用來表示【用秒表示的時(shí)間單位】比如second，常用的duration已經(jīng)定義好了，在std::chrono::duration下：

  •  ratio<3600, 1>：hours
  •  ratio<60, 1>：minutes
  •  ratio<1, 1>：seconds
  •  ratio<1, 1000>：microseconds
  •  ratio<1, 1000000>：microseconds
  •  ratio<1, 1000000000>：nanosecons

ratio的具體模板如下：

 
 
 
      
  
  
  1. template  class ratio; 
    2.

N代表分子，D代表分母，所以ratio表示一個(gè)分?jǐn)?shù)，我們可以自定義Period，比如ratio<2, 1>表示單位時(shí)間是2秒。

time_point

表示一個(gè)具體時(shí)間點(diǎn)，如2020年5月10日10點(diǎn)10分10秒，拿獲取當(dāng)前時(shí)間舉例：

 
 
 
      
  
  
  1. std::chrono::time_point Now() {  
    2.   
  
  
  2.    return std::chrono::high_resolution_clock::now(); 
    3.   
  
  
  3.  }  
    4.   
  
  
  4. // std::chrono::high_resolution_clock為高精度時(shí)鐘，下面會提到 
    5.

clocks

時(shí)鐘，chrono里面提供了三種時(shí)鐘：

  •  steady_clock
  •  system_clock
  •  high_resolution_clock

steady_clock

穩(wěn)定的時(shí)間間隔，表示相對時(shí)間，相對于系統(tǒng)開機(jī)啟動的時(shí)間，無論系統(tǒng)時(shí)間如何被更改，后一次調(diào)用now()肯定比前一次調(diào)用now()的數(shù)值大，可用于計(jì)時(shí)。

system_clock

表示當(dāng)前的系統(tǒng)時(shí)鐘，可以用于獲取當(dāng)前時(shí)間：

 
 
 
      
  
  
  1. int main() {  
    2.   
  
  
  2.    using std::chrono::system_clock;  
    3.   
  
  
  3.    system_clock::time_point today = system_clock::now();  
    4.   
  
  
  4.    std::time_t tt = system_clock::to_time_t(today);  
    5.   
  
  
  5.    std::cout << "today is: " << ctime(&tt);  
    6.   
  
  
  6.    return 0;  
    7.   
  
  
  7. }  
    8.   
  
  
  8. // today is: Sun May 10 09:48:36 2020 
    9.

high_resolution_clock

high_resolution_clock表示系統(tǒng)可用的最高精度的時(shí)鐘，實(shí)際上就是system_clock或者steady_clock其中一種的定義，官方?jīng)]有說明具體是哪個(gè)，不同系統(tǒng)可能不一樣，我之前看gcc chrono源碼中high_resolution_clock是steady_clock的typedef。

更多關(guān)于chrono的介紹可以看下我之前的文章：RAII妙用之計(jì)算函數(shù)耗時(shí)

新增數(shù)據(jù)結(jié)構(gòu)

  •  std::forward_list：單向鏈表，只可以前進(jìn)，在特定場景下使用，相比于std::list節(jié)省了內(nèi)存，提高了性能 
 
 
 
      
  
  
  1. std::forward_list fl = {1, 2, 3, 4, 5};  
    2.   
  
  
  2. for (const auto &elem : fl) { 
    3.   
  
  
  3.     cout << elem;  
    4.   
  
  
  4. } 
    5.
  •  std::unordered_set：基于hash表實(shí)現(xiàn)的set，內(nèi)部不會排序，使用方法和set類似
  •  std::unordered_map：基于hash表實(shí)現(xiàn)的map，內(nèi)部不會排序，使用方法和set類似
  •  std::array：數(shù)組，在越界訪問時(shí)拋出異常，建議使用std::array替代普通的數(shù)組
  •  std::tuple：元組類型，類似pair，但比pair擴(kuò)展性好 
 
 
 
      
  
  
  1. typedef std::tuple Mytuple;  
    2.   
  
  
  2. Mytuple t(0, 1, 2, 3);  
    3.   
  
  
  3. std::cout << "0 " << std::get<0>(t);  
    4.   
  
  
  4. std::cout << "1 " << std::get<1>(t);  
    5.   
  
  
  5. std::cout << "2 " << std::get<2>(t);  
    6.   
  
  
  6. std::cout << "3 " << std::get<3>(t); 
    7.

新增算法

  •  all_of：檢測表達(dá)式是否對范圍[first, last)中所有元素都返回true，如果都滿足，則返回true 

當(dāng)前名稱：C++11新特性，所有知識點(diǎn)都在這了！
鏈接分享：http://www.dlmjj.cn/article/djgopgo.html