c++11新特性,所有知識點都在這了!

c++程式設計師面試過程中基本上都會被問到c++11新特性吧，你是怎麼回答的呢？

本文基本上涵蓋了c++11的所有新特性，並有詳細代碼介紹其用法，對關鍵知識點做了深入分析，對重要的知識點我單獨寫了相關文章並附上了相關連結，我整理了完備的c++新特性腦圖（由於圖片太大，我沒有放在文章裡，同學可以在後臺回復消息「新特性」，即可下載完整圖片）。

auto & decltype

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

cont int &i = 1;int a = 2;decltype(i) b = 2; 
關於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關於並發引入了好多好東西，有：
詳細介紹請看：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++) {    cout << *iter << endl;}
for (int i : vec) { cout << "i" << endl;}
委託構造函數
委託構造函數允許在同一個類中一個構造函數調用另外一個構造函數，可以在變量初始化時簡化操作，通過代碼來感受下委託構造函數的妙處吧：
不使用委託構造函數：
struct A {   A(){}   A(int a) { a_ = a; }
   A(int a, int b) {        a_ = a;       b_ = b;  }
   A(int a, int b, int c) {        a_ = a;       b_ = b;       c_ = c;  }
   int a_;   int b_;   int c_;};
使用委託構造函數：
struct A {   A(){}   A(int a) { a_ = a; }
   A(int a, int b) : A(a) { b_ = b; }
   A(int a, int b, int c) : A(a, b) { c_ = c; }
   int a_;   int b_;   int c_;};
初始化變量是不是方便了許多。
繼承構造函數
繼承構造函數可以讓派生類直接使用基類的構造函數，如果有一個派生類，我們希望派生類採用和基類一樣的構造方式，可以直接使用基類的構造函數，而不是再重新寫一遍構造函數，老規矩，看代碼：
不使用繼承構造函數：
struct Base {   Base() {}   Base(int a) { a_ = a; }
   Base(int a, int b) : Base(a) { b_ = b; }
   Base(int a, int b, int c) : Base(a, b) { c_ = 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) { a_ = a; }
   Base(int a, int b) : Base(a) { b_ = b; }
   Base(int a, int b, int c) : Base(a, b) { c_ = 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);    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 {        cout << "derived" << endl;  }
   void fu() override {          }};

示例代碼2：
struct Base final {   virtual void func() {       cout << "base" << endl;  }};
struct Derived : public Base{    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) {        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;    A aa(2);    return 0;}
const
因為要講後面的constexpr，所以這裡簡單介紹下const。
const字面意思為只讀，可用於定義變量，表示變量是只讀的，不可以更改，如果更改，編譯期間就會報錯。
主要用法如下：
用於定義常量，const的修飾的變量不可更改。
指針也可以使用const，這裡有個小技巧，從右向左讀，即可知道const究竟修飾的是指針還是指針所指向的內容。
char *const ptr; const char* ptr; 
在函數參數中使用const，一般會傳遞類對象時會傳遞一個const的引用或者指針，這樣可以避免對象的拷貝，也可以防止對象被修改。
class A{};void func(const A& a);
const修飾類的成員變量，表示是成員常量，不能被修改，可以在初始化列表中被賦值。
class A {const int value = 5;};class B {const int value;B(int v) : value(v){}};
修飾類成員函數，表示在該函數內不可以修改該類的成員變量。
class A{void func() const;};
修飾類對象，類對象只能調用該對象的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;    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)); std::this_thread::sleep_for(std::chrono::seconds(100)); 
其實沒必要這麼麻煩，也可以這麼寫：
std::this_thread::sleep_for(100ms); 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的倍數，這就是內存對齊。
為什麼要內存對齊
硬體平臺限制，內存以字節為單位，不同硬體平臺不一定支持任何內存地址的存取，一般可能以雙字節、4位元組等為單位存取內存，為了保證處理器正確存取數據，需要進行內存對齊。
提高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: 1thread1: 2thread1: 3thread1: 4thread2: 1thread2: 2thread2: 3thread2: 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 70.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 match_str = match.str();       if (match_str.size() > N) {           std::cout << " " << match_str << '\n';      }  }
   std::regex long_word_regex("(\\w{7,})");      std::string new_s = std::regex_replace(s, long_word_regex, "[$&]");   std::cout << new_s << '\n';}
chrono
c++11關於時間引入了chrono庫，源於boost，功能強大，chrono主要有三個點：
duration
std::chrono::duration表示一段時間，常見的單位有s、ms等，示例代碼：
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();}
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;}
high_resolution_clock
high_resolution_clock表示系統可用的最高精度的時鐘，實際上就是system_clock或者steady_clock其中一種的定義，官方沒有說明具體是哪個，不同系統可能不一樣，我之前看gcc chrono源碼中high_resolution_clock是steady_clock的typedef。
更多關於chrono的介紹可以看下我之前的文章：RAII妙用之計算函數耗時
新增數據結構
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);
新增算法
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); for (auto n : l) std::cout << n << ' ';
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;}
關於c++11的新特性基本上就是這些，相信各位看完一定會有所收穫。
參考資料https://zh.cppreference.com/w/cpp/language/range-forhttps://juejin.im/post/5dcaa857e51d457f7675360bhttps://zhuanlan.zhihu.com/p/21930436https://zh.wikipedia.org/wiki/Nullptrhttps://zh.wikipedia.org/wiki/Constexprhttps://zh.cppreference.com/w/cpp/language/enumhttps://kheresy.wordpress.com/2019/03/27/using-enum-class/https://zh.cppreference.com/w/cpp/language/unionhttp://c.biancheng.net/view/7165.htmlhttps://zhuanlan.zhihu.com/p/77585472http://www.cplusplus.com/reference/random/https://zh.cppreference.com/w/cpp/regexhttps://www.cnblogs.com/jwk000/p/3560086.htmlhttps://zh.cppreference.com/w/cpp/algorithm/all_any_none_of作者公眾號:
持續關注～