C++11 中值得關注的幾大變化

源文章來自前C++標準委員會的 Danny Kalev 的 The Biggest Changes in C++11 (and Why You Should Care)，賴勇浩作了一個中文翻譯在這裏。因此，我就不翻譯了，我在這裏僅對文中提到的這些變化「追問爲何要引入這些變化」的一個探討，只有知道爲了什麼，用在什麼地方，咱們才能真正學到這個知識。而以此你能夠更深刻地瞭解這些變化。因此，本文不是翻譯。由於寫得有些倉促，因此不免有問題，還請你們指正。

Lambda 表達式

Lambda表達式來源於函數式編程，說白就了就是在使用的地方定義函數，有的語言叫「閉包」，若是 lambda 函數沒有傳回值(例如 void )，其回返類型可被徹底忽略。 定義在與 lambda 函數相同做用域的變量參考也能夠被使用。這種的變量集合通常被稱做 closure（閉包）。我在這裏就再也不講這個事了。表達式的簡單語法以下，

[capture](parameters)->return_type {body}

原文的做者給出了下面的例子：

int main() { char s[] = "Hello World!"; int Uppercase = 0; //modified by the lambda for_each(s, s + sizeof(s), [&Uppercase](char c) { if (isupper(c)) Uppercase++; }); cout << Uppercase << " uppercase letters in: " << s << endl; }

在傳統的STL中for_each() 這個玩意最後那個參數須要一個「函數對象」，所謂函數對象，實際上是一個class，這個class重載了operator()，因而這個對象能夠像函數的式樣的使用。實現一個函數對象並不容易，須要使用template，好比下面這個例子就是函數對象的簡單例子（實際的實現遠比這個複雜）：

template <class T> class less { public: bool operator()(const T&l, const T&r)const { return l < r; } };

因此，C++引入Lambda的最主要緣由就是1）能夠定義匿名函數，2）編譯器會把其轉成函數對象。相信你會和我同樣，會疑問爲何之前STL中的ptr_fun()這個函數對象不能用？（ptr_fun()就是把一個天然函數轉成函數對象的）。緣由是，ptr_fun() 的侷限是其接收的天然函數只能有1或2個參數。

那麼，除了方便外，爲何必定要使用Lambda呢？它比傳統的函數或是函數對象有什麼好處呢？我我的所理解的是，這種函數之年以叫「閉包」，就是由於其限制了別人的訪問，更私有。也能夠認爲他是一次性的方法。Lambda表達式應該是簡潔的，極私有的，爲了更易的代碼和更方便的編程。

自動類型推導 auto

在這一節中，原文主要介紹了兩個關鍵字 auto 和 deltype，示例以下：

auto x=0; //x has type int because 0 is int auto c='a'; //char auto d=0.5; //double auto national_debt=14400000000000LL;//long long 

auto 最大的好處就是讓代碼簡潔，尤爲是那些模板類的聲明，好比：STL中的容器的迭代子類型。

vector<int>::const_iterator ci = vi.begin();

能夠變成：

auto ci = vi.begin();

模板這個特性讓C++的代碼變得很難讀，不信你能夠看看STL的源碼，那是一個亂啊。使用auto必需一個初始化值，編譯器能夠經過這個初始化值推導出類型。由於auto是來簡化模板類引入的代碼難讀的問題，如上面的示例，iteration這種類型就最適合用auto的，可是，咱們不該該把其濫用。

好比下面的代碼的可讀性就下降了。由於，我不知道ProcessData返回什麼？int? bool? 仍是對象？或是別的什麼？這讓你後面的程序不知道怎麼作。

auto obj = ProcessData(someVariables);

可是下面的程序就沒有問題，由於pObject的型別在後面的new中有了。

auto pObject = new SomeType<OtherType>::SomeOtherType();

自動化推導 decltype

關於 decltype 是一個操做符，其能夠評估括號內表達式的類型，其規則以下：

若是表達式e是一個變量，那麼就是這個變量的類型。

若是表達式e是一個函數，那麼就是這個函數返回值的類型。

若是不符合1和2，若是e是左值，類型爲T，那麼decltype(e)是T&；若是是右值，則是T。

原文給出的示例以下，咱們能夠看到，這個讓的確咱們的定義變量省了不少事。

const vector<int> vi; typedef decltype (vi.begin()) CIT; CIT another_const_iterator; 

還有一個適合的用法是用來typedef函數指針，也會省不少事。好比：

decltype(&myfunc) pfunc = 0; typedef decltype(&A::func1) type; 

auto 和 decltype 的差異和關係

Wikipedia 上是這麼說的（關於decltype的規則見上）

#include <vector> int main() { const std::vector<int> v(1); auto a = v[0]; // a 的類型是 int decltype(v[0]) b = 1; // b 的類型是 const int&, 由於函數的返回類型是 // std::vector<int>::operator[](size_type) const auto c = 0; // c 的類型是 int auto d = c; // d 的類型是 int decltype(c) e; // e 的類型是 int, 由於 c 的類型是int decltype((c)) f = c; // f 的類型是 int&, 由於 (c) 是左值 decltype(0) g; // g 的類型是 int, 由於 0 是右值 } 

若是auto 和 decltype 在一塊兒使用會是什麼樣子？能看下面的示例，下面這個示例也是引入decltype的一個緣由——讓C++有能力寫一個 「 forwarding function 模板」，

template< typename LHS, typename RHS> auto AddingFunc(const LHS &lhs, const RHS &rhs) -> decltype(lhs+rhs) {return lhs + rhs;} 

這個函數模板看起來至關費解，其用到了auto 和 decltype 來擴展了已有的模板技術的不足。怎麼個不足呢？在上例中，我不知道AddingFunc會接收什麼樣類型的對象，這兩個對象的 + 操做符返回的類型也不知道，老的模板函數沒法定義AddingFunc返回值和這兩個對象相加後的返回值匹配，因此，你可使用上述的這種定義。

統一的初始化語法

C/C++的初始化的方法比較，C++ 11 用大括號統一了這些初始化的方法。

好比：POD的類型。

int arr[4]={0,1,2,3}; struct tm today={0}; 

關於POD相說兩句，所謂POD就是Plain Old Data，當class/struct是極簡的(trivial)、屬於標準佈局(standard-layout)，以及他的全部非靜態（non-static）成員都是POD時，會被視爲POD。如：

struct A { int m; }; // POD struct B { ~B(); int m; }; // non-POD, compiler generated default ctor struct C { C() : m() {}; ~C(); int m; }; // non-POD, default-initialising m 

POD的初始化有點怪，好比上例，new A; 和new A(); 是不同的，對於其內部的m，前者沒有被初始化，後者被初始化了（不一樣 的編譯器行爲不同，VC++和GCC不同）。而非POD的初始化，則都會被初始化。

從這點能夠看出，C/C++的初始化問題很奇怪，因此，在C++ 2011版中就作了統一。原文做者給出了以下的示例：

C c {0,0}; //C++11 only. 至關於: C c(0,0); int* a = new int[3] { 1, 2, 0 }; /C++11 only class X { int a[4]; public: X() : a{1,2,3,4} {} //C++11, member array initializer }; 

容器的初始化：

// C++11 container initializer vector<string> vs={ "first", "second", "third"}; map singers = { {"Lady Gaga", "+1 (212) 555-7890"} ,{"Beyonce Knowles", "+1 (212) 55-0987"} }; 

還支持像Java同樣的成員初始化：

class C { int a=7; //C++11 only public: C(); }; 

Delete 和 Default 函數

咱們知道C++的編譯器在你沒有定義某些成員函數的時候會給你的類自動生成這些函數，好比，構造函數，拷貝構造，析構函數，賦值函數。有些時候，咱們不想要這些函數，好比，構造函數，由於咱們想作實現單例模式。傳統的作法是將其聲明成private類型。

在新的C++中引入了兩個指示符，delete意爲告訴編譯器不自動產生這個函數，default告訴編譯器產生一個默認的。原文給出了下面兩個例子：

struct A { A()=default; //C++11 virtual ~A()=default; //C++11 }; 

再如delete

struct NoCopy { NoCopy & operator =( const NoCopy & ) = delete; NoCopy ( const NoCopy & ) = delete; }; NoCopy a; NoCopy b(a); //compilation error, copy ctor is deleted 

這裏，我想說一下，爲何咱們須要default？我什麼都不寫不就是default嗎？不全然是，好比構造函數，由於只要你定義了一個構造函數，編譯器就不會給你生成一個默認的了。因此，爲了要讓默認的和自定義的共存，才引入這個參數，以下例所示：

struct SomeType { SomeType() = default; // 使用編譯器生成的默認構造函數 SomeType(OtherType value); }; 

關於delete還有兩個有用的地方是

1）讓你的對象只能生成在棧內存上：

struct NonNewable { void *operator new(std::size_t) = delete; }; 

2）阻止函數的其形參的類型調用：（若嘗試以 double 的形參調用 f()，將會引起編譯期錯誤， 編譯器不會自動將 double 形參轉型爲 int 再調用f()，若是傳入的參數是double，則會出現編譯錯誤）

void f(int i); void f(double) = delete; 

nullptr

C/C++的NULL宏是個被有不少潛在BUG的宏。由於有的庫把其定義成整數0，有的定義成 (void*)0。在C的時代還好。可是在C++的時代，這就會引起不少問題。你能夠上網看看。這是爲何須要 nullptr 的緣由。 nullptr 是強類型的。

void f(int); //#1 void f(char *);//#2 //C++03 f(0); //二義性 //C++11 f(nullptr); //無二義性，調用f(char*) 

因此在新版中請以 nullptr 初始化指針。

委託構造

在之前的C++中，構造函數之間不能互相調用，因此，咱們在寫這些類似的構造函數裏，咱們會把相同的代碼放到一個私有的成員函數中。

class SomeType {
private:
    int number;
    string name;
    SomeType( int i, string& s ) : number(i), name(s){}
public:
    SomeType( )               : SomeType( 0, "invalid" ){}
    SomeType( int i )         : SomeType( i, "guest" ){}
    SomeType( string& s ) : SomeType( 1, s ){ PostInit(); }
};

可是，爲了方便並不足讓「委託構造」這個事出現，最主要的問題是，基類的構造不能直接成爲派生類的構造，就算是基類的構造函數夠了，派生類還要本身寫本身的構造函數：

class BaseClass
{
public:
    BaseClass(int iValue);
};

class DerivedClass : public BaseClass
{
public:
    using BaseClass::BaseClass;
};

上例中，派生類手動繼承基類的構造函數， 編譯器可使用基類的構造函數完成派生類的構造。 而將基類的構造函數帶入派生類的動做 沒法選擇性地部分帶入， 因此，要不就是繼承基類所有的構造函數，要不就是一個都不繼承(不手動帶入)。 此外，若牽涉到多重繼承，從多個基類繼承而來的構造函數不能夠有相同的函數簽名(signature)。 而派生類的新加入的構造函數也不能夠和繼承而來的基類構造函數有相同的函數簽名，由於這至關於重複聲明。（所謂函數簽名就是函數的參數類型和順序不）

右值引用和move語義

在老版的C++中，臨時性變量（稱爲右值」R-values」，位於賦值操做符之右）常常用做交換兩個變量。好比下面的示例中的tmp變量。示例中的那個函數須要傳遞兩個string的引用，可是在交換的過程當中產生了對象的構造，內存的分配還有對象的拷貝構造等等動做，成本比較高。

void naiveswap(string a, string b)
{
    string temp = a;
    a=b;
    b=temp;
}

C++ 11增長一個新的引用（reference）類型稱做右值引用（R-value reference），標記爲typename &&。他們可以以non-const值的方式傳入，容許對象去改動他們。這項修正容許特定對象創造出move語義。

舉例而言，上面那個例子中，string類中保存了一個動態內存分存的char*指針，若是一個string對象發生拷貝構造（如：函數返回），string類裏的char*內存只能經過建立一個新的臨時對象，並把函數內的對象的內存copy到這個新的對象中，而後銷燬臨時對象及其內存。這是原來C++性能上重點被批評的事。

能過右值引用，string的構造函數須要改爲「move構造函數」，以下所示。這樣一來，使得對某個stirng的右值引用能夠單純地從右值複製其內部C-style的指針到新的string，而後留下空的右值。這個操做不須要內存數組的複製，並且空的暫時對象的析構也不會釋放內存。其更有效率。

class string
{
    string (string&&); //move constructor
    string&& operator=(string&&); //move assignment operator
};

The C++11 STL中普遍地使用了右值引用和move語議。所以，不少算法和容器的性能都被優化了。

C++ 11 STL 標準庫

C++ STL庫在2003年經歷了很大的整容手術 Library Technical Report 1 (TR1)。 TR1 中出現了不少新的容器類 (unordered_set, unordered_map, unordered_multiset, 和 unordered_multimap) 以及一些新的庫支持諸如：正則表達式， tuples，函數對象包裝，等等。 C++11 批准了 TR1 成爲正式的C++標準，還有一些TR1 後新加的一些庫，從而成爲了新的C++ 11 STL標準庫。這個庫主要包含下面的功能：

線程庫

這們就很少說了，之前的STL飽受線程安全的批評。如今好 了。C++ 11 支持線程類了。這將涉及兩個部分：第1、設計一個可使多個線程在一個進程中共存的內存模型；第2、爲線程之間的交互提供支持。第二部分將由程序庫提供支持。你們能夠看看promises and futures，其用於對象的同步。 async() 函數模板用於發起併發任務，而 thread_local 爲線程內的數據指定存儲類型。更多的東西，能夠查看 Anthony Williams的 Simpler Multithreading in C++0x.

新型智能指針

C++98 的知能指針是 auto_ptr， 在C++ 11中被廢棄了。C++11  引入了兩個指針類： shared_ptr 和 unique_ptr。 shared_ptr只是單純的引用計數指針，unique_ptr 是用來取代auto_ptr。 unique_ptr 提供 auto_ptr 大部份特性，惟一的例外是 auto_ptr 的不安全、隱性的左值搬移。不像 auto_ptr，unique_ptr 能夠存放在 C++0x 提出的那些能察覺搬移動做的容器之中。

爲何要這麼幹？你們能夠看看《More Effective C++》中對 auto_ptr的討論。

新的算法

定義了一些新的算法： all_of(), any_of() 和 none_of()。

#include <algorithm>

//C++11 code
//are all of the elements positive?
all_of(first, first+n, ispositive()); //false
//is there at least one positive element?
any_of(first, first+n, ispositive());//true
// are none of the elements positive?
none_of(first, first+n, ispositive()); //false

使用新的copy_n()算法，你能夠很方便地拷貝數組。

#include <algorithm>
int source[5]={0,12,34,50,80};
int target[5];
//copy 5 elements from source to target
copy_n(source,5,target);

使用 iota() 能夠用來建立遞增的數列。以下例所示：

include <numeric>

int a[5]={0};
char c[3]={0};
iota(a, a+5, 10); //changes a to {10,11,12,13,14}
iota(c, c+3, 'a'); //{'a','b','c'}

總之，看下來，C++11 仍是很學院派，不少實用的東西仍是沒有，好比： XML，sockets，reflection，固然還有垃圾回收。看來要等到C++ 20了。呵呵。不過C++ 11在性能上仍是很快。參看 Google’s benchmark tests。原文還引用Stroustrup 的觀點：C++11 是一門新的語言——一個更好的 C++。

若是把全部的改變都列出來，你會發現真多啊。我估計C++ Primer那本書的厚度要增長至少30%以上。C++的門檻會不會愈來愈高了呢？我不知道，但我我的以爲這門語言的確是變得愈來愈使人望而卻步了。（想起了某人和我說的一句話——學技術真的是太累了，仍是搞方法論好混些？）

（全文完）