C++11有什么新特性

這篇文章主要介紹“C++11有什么新特性”，在日常操作中，相信很多人在C++11有什么新特性問題上存在疑惑，小編查閱了各式資料，整理出簡單好用的操作方法，希望對大家解答”C++11有什么新特性”的疑惑有所幫助！接下來，請跟著小編一起來學習吧！

auto & decltype

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

•  auto：讓編譯器在編譯器就推導出變量的類型，可以通過=右邊的類型推導出變量的類型。

auto a = 10; // 10是int型，可以自動推導出a是int

•  decltype：相對于auto用于推導變量類型，而decltype則用于推導表達式類型，這里只用于編譯器分析表達式的類型，表達式實際不會進行運算。 

cont int &i = 1;  int a = 2;  decltype(i) b = 2; // b是const int&

關于auto和decltype的詳細介紹請看：一文吃透C++11中auto和decltype知識點

左值右值

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

•  左值：可以取地址并且有名字的東西就是左值。

•  右值：不能取地址的沒有名字的東西就是右值。

•  純右值：運算表達式產生的臨時變量、不和對象關聯的原始字面量、非引用返回的臨時變量、lambda表達式等都是純右值。

•  將亡值：可以理解為即將要銷毀的值。

•  左值引用：對左值進行引用的類型。

•  右值引用：對右值進行引用的類型。

•  移動語義：轉移資源所有權，類似于轉讓或者資源竊取的意思，對于那塊資源，轉為自己所擁有，別人不再擁有也不會再使用。

•  完美轉發：可以寫一個接受任意實參的函數模板，并轉發到其它函數，目標函數會收到與轉發函數完全相同的實參。

•  返回值優化：當函數需要返回一個對象實例時候，就會創建一個臨時對象并通過復制構造函數將目標對象復制到臨時對象，這里有復制構造函數和析構函數會被多余的調用到，有代價，而通過返回值優化，C++標準允許省略調用這些復制構造函數。

這里的詳細介紹請看：左值引用、右值引用、移動語義、完美轉發，你知道的不知道的都在這里

列表初始化

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

std::function & std::bind & lambda表達式

c++11新增了std::function、std::bind、lambda表達式等封裝使函數調用更加方便，詳細介紹請看：搞定c++11新特性std::function和lambda表達式

模板的改進

C++11關于模板有一些細節的改進：

•  模板的右尖括號

•  模板的別名

•  函數模板的默認模板參數

詳細介紹請看：C++11的模板改進

并發

c++11關于并發引入了好多好東西，有：

•  std::thread相關

•  std::mutex相關

•  std::lock相關

•  std::atomic相關

•  std::call_once相關

•  volatile相關

•  std::condition_variable相關

•  std::future相關

•  async相關

詳細介紹請看：c++11新特性之線程相關所有知識點

這里也使用c++11來實現的線程池和定時器，可以看：

C++線程池的實現之格式修訂版

C++定時器的實現之格式修訂版

智能指針

很多人談到c++，說它特別難，可能有一部分就是因為c++的內存管理吧，不像java那樣有虛擬機動態的管理內存，在程序運行過程中可能就會出現內存泄漏，然而這種問題其實都可以通過c++11引入的智能指針來解決，相反我還認為這種內存管理還是c++語言的優勢，因為盡在掌握。

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

•  std::shared_ptr

•  std::weak_ptr

•  std::unique_ptr

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

基于范圍的for循環

直接看代碼

vector<int> vec;  for (auto iter = vec.begin(); iter != vec.end(); iter++) { // before c++11     cout << *iter << endl;  }  for (int i : vec) { // c++11基于范圍的for循環  cout << "i" << endl;  }

委托構造函數

委托構造函數允許在同一個類中一個構造函數調用另外一個構造函數，可以在變量初始化時簡化操作，通過代碼來感受下委托構造函數的妙處吧：

不使用委托構造函數：

struct A {     A(){}     A(int a) { aa_ = a; }     A(int a, int b) { // 好麻煩         aa_ = a;         bb_ = b;    }     A(int a, int b, int c) { // 好麻煩         aa_ = a;         bb_ = b;         cc_ = c;    }     int a_;    int b_;     int c_;  };

使用委托構造函數：

struct A {     A(){}     A(int a) { aa_ = a; }     A(int a, int b) : A(a) { bb_ = b; }     A(int a, int b, int c) : A(a, b) { cc_ = c; }     int a_;     int b_;     int c_;  };

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

繼承構造函數

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

不使用繼承構造函數：

struct Base {     Base() {}     Base(int a) { aa_ = a; }     Base(int a, int b) : Base(a) { bb_ = b; }     Base(int a, int b, int c) : Base(a, b) { cc_ = c; }     int a_;     int b_;     int c_;  };  struct Derived : Base {     Derived() {}     Derived(int a) : Base(a) {} // 好麻煩     Derived(int a, int b) : Base(a, b) {} // 好麻煩     Derived(int a, int b, int c) : Base(a, b, c) {} // 好麻煩  };  int main() {     Derived a(1, 2, 3);     return 0;  }

使用繼承構造函數：

struct Base {     Base() {}     Base(int a) { aa_ = a; }     Base(int a, int b) : Base(a) { bb_ = b; }     Base(int a, int b, int c) : Base(a, b) { cc_ = c; }     int a_;     int b_;     int c_;  };  struct Derived : Base {     using Base::Base;  };  int main() {     Derived a(1, 2, 3);     return 0;  }

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

nullptr

nullptr是c++11用來表示空指針新引入的常量值，在c++中如果表示空指針語義時建議使用nullptr而不要使用NULL，因為NULL本質上是個int型的0，其實不是個指針。舉例：

void func(void *ptr) {     cout << "func ptr" << endl;  }  void func(int i) {     cout << "func i" << endl;  }  int main() {     func(NULL); // 編譯失敗，會產生二義性     func(nullptr); // 輸出func ptr     return 0;  }

final & override

c++11關于繼承新增了兩個關鍵字，final用于修飾一個類，表示禁止該類進一步派生和虛函數的進一步重載，override用于修飾派生類中的成員函數，標明該函數重寫了基類函數，如果一個函數聲明了override但父類卻沒有這個虛函數，編譯報錯，使用override關鍵字可以避免開發者在重寫基類函數時無意產生的錯誤。

示例代碼1：

struct Base {     virtual void func() {         cout << "base" << endl;    }  };  struct Derived : public Base{     void func() override { // 確保func被重寫         cout << "derived" << endl;    }     void fu() override { // error，基類沒有fu()，不可以被重寫        }  };

示例代碼2：

struct Base final {     virtual void func() {         cout << "base" << endl;    }  };  struct Derived : public Base{ // 編譯失敗，final修飾的類不可以被繼承     void func() override {         cout << "derived" << endl;    }  };

default

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

struct A {     int a;     A(int i) { a = i; }  };  int main() {     A a; // 編譯出錯     return 0;  }

上面代碼編譯出錯，因為沒有匹配的構造函數，因為編譯器沒有生成默認構造函數，而通過default，程序員只需在函數聲明后加上“=default;”，就可將該函數聲明為 defaulted 函數，編譯器將為顯式聲明的 defaulted 函數自動生成函數體，如下：

struct A {     A() = default;     int a;     A(int i) { a = i; }  };  int main() {     A a;     return 0;  }

編譯通過。

delete

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

struct A {     A() = default;     int a;     A(int i) { a = i; }  };  int main() {     A a1;     A a2 = a1;  // 正確，調用編譯器隱式生成的默認拷貝構造函數     A a3;     a3 = a1;  // 正確，調用編譯器隱式生成的默認拷貝賦值操作符  }

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

struct A {     A() = default;     A(const A&) = delete;     A& operator=(const A&) = delete;     int a;     A(int i) { a = i; }  };  int main() {     A a1;     A a2 = a1;  // 錯誤，拷貝構造函數被禁用     A a3;     a3 = a1;  // 錯誤，拷貝賦值操作符被禁用  }

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

explicit

explicit專用于修飾構造函數，表示只能顯式構造，不可以被隱式轉換，根據代碼看explicit的作用：

不用explicit：

struct A {     A(int value) { // 沒有explicit關鍵字         cout << "value" << endl;    }  };  int main() {     A a = 1; // 可以隱式轉換     return 0;  }

使用explicit:

struct A {     explicit A(int value) {         cout << "value" << endl;    }  };  int main() {     A a = 1; // error，不可以隱式轉換     A aa(2); // ok     return 0;  }

const

因為要講后面的constexpr，所以這里簡單介紹下const。

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

主要用法如下：

1. 鴻蒙官方戰略合作共建——HarmonyOS技術社區

2.  用于定義常量，const的修飾的變量不可更改。

const int value = 5;

    2.  指針也可以使用const，這里有個小技巧，從右向左讀，即可知道const究竟修飾的是指針還是指針所指向的內容。

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

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

class A{};  void func(const A& a);

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

class A {  const int value = 5;  };  class B {  const int value;  B(int v) : value(v){}  };

    5.  修飾類成員函數，表示在該函數內不可以修改該類的成員變量。

class A{  void func() const;  };

    6.  修飾類對象，類對象只能調用該對象的const成員函數。

class A {  void func() const;  };  const A a;  a.func();

constexpr

constexpr是c++11新引入的關鍵字，用于編譯時的常量和常量函數，這里直接介紹constexpr和const的區別：

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

#include<iostream>  using namespace std;  constexpr int func(int i) {     return i + 1;  }  int main() {    int i = 2;     func(i);// 普通函數     func(2);// 編譯期間就會被計算出來  }

enum class

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

不帶作用域的枚舉代碼：

enum AColor {     kRed,     kGreen,     kBlue  };  enum BColor {     kWhite,     kBlack,     kYellow  };  int main() {     if (kRed == kWhite) {         cout << "red == white" << endl;    }     return 0;  }

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

有作用域的枚舉代碼：

enum class AColor {     kRed,     kGreen,     kBlue  };  enum class BColor {     kWhite,     kBlack,     kYellow  };  int main() {     if (AColor::kRed == BColor::kWhite) { // 編譯失敗         cout << "red == white" << endl;    }     return 0;  }

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

enum class AColor : char {     kRed,    kGreen,     kBlue };

我們平時編程過程中使用枚舉，一定要使用有作用域的枚舉取代傳統的枚舉。

非受限聯合體

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

struct A {     int a;     int *b;  };  union U {     A a; // 非POD類型 c++11之前不可以這樣定義聯合體     int b;  };

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

sizeof

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

c++11前：

struct A {     int data[10];     int a;  };  int main() {     A a;     cout << "size " << sizeof(a.data) << endl;     return 0;  }

c++11后：

struct A {     int data[10];     int a;  };  int main() {     cout << "size " << sizeof(A::data) << endl;     return 0;  }

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

assertion

static_assert(true/false, message);

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

自定義字面量

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

std::this_thread::sleep_for(std::chrono::milliseconds(100)); // 100ms  std::this_thread::sleep_for(std::chrono::seconds(100)); // 100s

其實沒必要這么麻煩，也可以這么寫：

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

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

struct mytype {     unsigned long long value;  };  constexpr mytype operator"" _mytype ( unsigned long long n ) {     return mytype{n};  }  mytype mm = 123_mytype;  cout << mm.value << endl;

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

內存對齊

什么是內存對齊

理論上計算機對于任何變量的訪問都可以從任意位置開始，然而實際上系統會對這些變量的存放地址有限制，通常將變量首地址設為某個數N的倍數，這就是內存對齊。

為什么要內存對齊

1. 鴻蒙官方戰略合作共建——HarmonyOS技術社區

2.  硬件平臺限制，內存以字節為單位，不同硬件平臺不一定支持任何內存地址的存取，一般可能以雙字節、4字節等為單位存取內存，為了保證處理器正確存取數據，需要進行內存對齊。

3.  提高CPU內存訪問速度，一般處理器的內存存取粒度都是N的整數倍，假如訪問N大小的數據，沒有進行內存對齊，有可能就需要兩次訪問才可以讀取出數據，而進行內存對齊可以一次性把數據全部讀取出來，提高效率。

在c++11之前如果想創建內存對齊需要：

void align_cpp11_before()  {     static char data[sizeof(void *) + sizeof(A)];    const uintptr_t kAlign = sizeof(void *) - 1;     char *align_ptr =         reinterpret_cast<char *>(reinterpret_cast<uintptr_t>(data + kAlign) & ~kAlign);     A *attr = new (align_ptr) A;  }

c++11關于內存對齊新增了一些函數：

void align_cpp11_after()  {    static std::aligned_storage<sizeof(A),                                 alignof(A)>::type data;     A *attr = new (&data) A;  }

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

thread_local

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

#include <iostream>  #include <thread>  class A {    public:     A() {}     ~A() {}     void test(const std::string &name) {         thread_local int count = 0;         ++count;         std::cout << name << ": " << count << std::endl;    }  }; void func(const std::string &name) {     A a1;     a1.test(name);     a1.test(name);     A a2;     a2.test(name);     a2.test(name);  }  int main() {     std::thread(func, "thread1").join();     std::thread(func, "thread2").join();     return 0;  }

輸出：

thread1: 1  thread1: 2  thread1: 3  thread1: 4  thread2: 1  thread2: 2  thread2: 3  thread2: 4

驗證上述說法，對于一個線程私有變量，一個線程擁有且只擁有一個該實例，類似于static。

基礎數值類型

c++11新增了幾種數據類型：long long、char16_t、char32_t等

隨機數功能

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

#include <time.h>  #include <iostream>  #include <random>  using namespace std;  int main() {     std::default_random_engine random(time(nullptr));     std::uniform_int_distribution<int> int_dis(0, 100); // 整數均勻分布     std::uniform_real_distribution<float> real_dis(0.0, 1.0); // 浮點數均勻分布     for (int i = 0; i < 10; ++i) {         cout << int_dis(random) << ' ';    }     cout << endl;     for (int i = 0; i < 10; ++i) {         cout << real_dis(random) << ' ';    }     cout << endl;     return 0;  }

輸出：

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

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

正則表達式

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

#include <iostream>  #include <iterator>  #include <regex>  #include <string>  int main() {     std::string s = "I know, I'll use2 regular expressions.";  // 忽略大小寫     std::regex self_regex("REGULAR EXPRESSIONS", std::regex_constants::icase);     if (std::regex_search(s, self_regex)) {         std::cout << "Text contains the phrase 'regular expressions'\n";    }     std::regex word_regex("(\\w+)");  // 匹配字母數字等字符     auto words_begin = std::sregex_iterator(s.begin(), s.end(), word_regex);     auto words_end = std::sregex_iterator();     std::cout << "Found " << std::distance(words_begin, words_end) << " words\n";     const int N = 6;     std::cout << "Words longer than " << N << " characters:\n";     for (std::sregex_iterator i = words_begin; i != words_end; ++i) {         std::smatch match = *i;         std::string matchmatch_str = match.str();         if (match_str.size() > N) {             std::cout << " " << match_str << '\n';        }    }     std::regex long_word_regex("(\\w{7,})");     // 超過7個字符的單詞用[]包圍     std::string new_s = std::regex_replace(s, long_word_regex, "[$&]");     std::cout << new_s << '\n';  }

chrono

c++11關于時間引入了chrono庫，源于boost，功能強大，chrono主要有三個點：

•  duration

•  time_point

•  clocks

duration

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

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

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

typedef duration<int64_t, milli> milliseconds;  typedef duration<int64_t> seconds;

duration具體模板如下：

1 template <class Rep, class Period = ratio<1> > class duration;

Rep表示一種數值類型，用來表示Period的數量，比如int、float、double，Period是ratio類型，用來表示【用秒表示的時間單位】比如second，常用的duration<Rep, Period>已經定義好了，在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的具體模板如下：

template <intmax_t N, intmax_t D = 1> class ratio;

N代表分子，D代表分母，所以ratio表示一個分數，我們可以自定義Period，比如ratio<2, 1>表示單位時間是2秒。

time_point

表示一個具體時間點，如2020年5月10日10點10分10秒，拿獲取當前時間舉例：

std::chrono::time_point<std::chrono::high_resolution_clock> Now() {     return std::chrono::high_resolution_clock::now();  }  // std::chrono::high_resolution_clock為高精度時鐘，下面會提到

clocks

時鐘，chrono里面提供了三種時鐘：

•  steady_clock

•  system_clock

•  high_resolution_clock

steady_clock

穩定的時間間隔，表示相對時間，相對于系統開機啟動的時間，無論系統時間如何被更改，后一次調用now()肯定比前一次調用now()的數值大，可用于計時。

system_clock

表示當前的系統時鐘，可以用于獲取當前時間：

int main() {     using std::chrono::system_clock;     system_clock::time_point today = system_clock::now();     std::time_t tt = system_clock::to_time_t(today);     std::cout << "today is: " << ctime(&tt);     return 0;  }  // today is: Sun May 10 09:48:36 2020

high_resolution_clock

high_resolution_clock表示系統可用的最高精度的時鐘，實際上就是system_clock或者steady_clock其中一種的定義，官方沒有說明具體是哪個，不同系統可能不一樣，我之前看gcc chrono源碼中high_resolution_clock是steady_clock的typedef。

更多關于chrono的介紹可以看下我之前的文章：RAII妙用之計算函數耗時

新增數據結構

•  std::forward_list：單向鏈表，只可以前進，在特定場景下使用，相比于std::list節省了內存，提高了性能 

std::forward_list<int> fl = {1, 2, 3, 4, 5};  for (const auto &elem : fl) {     cout << elem;  }

•  std::unordered_set：基于hash表實現的set，內部不會排序，使用方法和set類似

•  std::unordered_map：基于hash表實現的map，內部不會排序，使用方法和set類似

•  std::array：數組，在越界訪問時拋出異常，建議使用std::array替代普通的數組

•  std::tuple：元組類型，類似pair，但比pair擴展性好 

typedef std::tuple<int, double, int, double> Mytuple;  Mytuple t(0, 1, 2, 3);  std::cout << "0 " << std::get<0>(t);  std::cout << "1 " << std::get<1>(t);  std::cout << "2 " << std::get<2>(t);  std::cout << "3 " << std::get<3>(t);

新增算法

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

std::vector<int> v(10, 2);  if (std::all_of(v.cbegin(), v.cend(), [](int i) { return i % 2 == 0; })) {  std::cout << "All numbers are even\n";  }

•  any_of：檢測表達式是否對范圍[first, last)中至少一個元素返回true，如果滿足，則返回true，否則返回false，用法和上面一樣

•  none_of：檢測表達式是否對范圍[first, last)中所有元素都不返回true，如果都不滿足，則返回true，否則返回false，用法和上面一樣

•  find_if_not：找到第一個不符合要求的元素迭代器，和find_if相反

•  copy_if：復制滿足條件的元素

•  itoa：對容器內的元素按序遞增 

std::vector<int> l(10);  std::iota(l.begin(), l.end(), 19); // 19為初始值  for (auto n : l) std::cout << n << ' ';  // 19 20 21 22 23 24 25 26 27 28

•  minmax_element：返回容器內最大元素和最小元素位置 

int main() {     std::vector<int> v = {3, 9, 1, 4, 2, 5, 9};     auto result = std::minmax_element(v.begin(), v.end());     std::cout << "min element at: " << *(result.first) << '\n';     std::cout << "max element at: " << *(result.second) << '\n';     return 0;  }  // min element at: 1 // max element at: 9

•  is_sorted、is_sorted_until：返回容器內元素是否已經排好序。

到此，關于“C++11有什么新特性”的學習就結束了，希望能夠解決大家的疑惑。理論與實踐的搭配能更好的幫助大家學習，快去試試吧！若想繼續學習更多相關知識，請繼續關注億速云網站，小編會繼續努力為大家帶來更多實用的文章！