源文章來(lái)自前C++標(biāo)準(zhǔn)委員會(huì)的 Danny Kalev 的 The Biggest Changes in C++11 (and Why You Should Care)，賴勇浩做了一個(gè)中文翻譯在這里。所以，我就不翻譯了，我在這里僅對(duì)文中提到的這些變化“追問(wèn)為什么要引入這些變化”的一個(gè)探討，只有知道為了什么，用在什么地方，我們才能真正學(xué)到這個(gè)知識(shí)。而以此你可以更深入地了解這些變化。所以，本文不是翻譯。因?yàn)閷懙糜行﹤}(cāng)促，所以難免有問(wèn)題，還請(qǐng)大家指正。

Lambda 表達(dá)式

Lambda表達(dá)式來(lái)源于函數(shù)式編程，說(shuō)白就了就是在使用的地方定義函數(shù)，有的語(yǔ)言叫“閉包”，如果 lambda 函數(shù)沒(méi)有傳回值(例如 void )，其回返類型可被完全忽略。 定義在與 lambda 函數(shù)相同作用域的變量參考也可以被使用。這種的變量集合一般被稱作 closure（閉包）。我在這里就不再講這個(gè)事了。表達(dá)式的簡(jiǎn)單語(yǔ)法如下，

[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;
}

在傳統(tǒng)的STL中for_each() 這個(gè)玩意最后那個(gè)參數(shù)需要一個(gè)“函數(shù)對(duì)象”，所謂函數(shù)對(duì)象，其實(shí)是一個(gè)class，這個(gè)class重載了operator()，于是這個(gè)對(duì)象可以像函數(shù)的式樣的使用。實(shí)現(xiàn)一個(gè)函數(shù)對(duì)象并不容易，需要使用template，比如下面這個(gè)例子就是函數(shù)對(duì)象的簡(jiǎn)單例子（實(shí)際的實(shí)現(xiàn)遠(yuǎn)比這個(gè)復(fù)雜）：

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

所以，C++引入Lambda的最主要原因就是1）可以定義匿名函數(shù)，2）編譯器會(huì)把其轉(zhuǎn)成函數(shù)對(duì)象。相信你會(huì)和我一樣，會(huì)疑問(wèn)為什么以前STL中的ptr_fun()這個(gè)函數(shù)對(duì)象不能用？（ptr_fun()就是把一個(gè)自然函數(shù)轉(zhuǎn)成函數(shù)對(duì)象的）。原因是，ptr_fun() 的局限是其接收的自然函數(shù)只能有1或2個(gè)參數(shù)。

那么，除了方便外，為什么一定要使用Lambda呢？它比傳統(tǒng)的函數(shù)或是函數(shù)對(duì)象有什么好處呢？我個(gè)人所理解的是，這種函數(shù)之年以叫“閉包”，就是因?yàn)槠湎拗屏藙e人的訪問(wèn)，更私有。也可以認(rèn)為他是一次性的方法。Lambda表達(dá)式應(yīng)該是簡(jiǎn)潔的，極私有的，為了更易的代碼和更方便的編程。

自動(dòng)類型推導(dǎo) auto

在這一節(jié)中，原文主要介紹了兩個(gè)關(guān)鍵字 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 最大的好處就是讓代碼簡(jiǎn)潔，尤其是那些模板類的聲明，比如：STL中的容器的迭代子類型。

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

可以變成：

auto ci = vi.begin();

模板這個(gè)特性讓C++的代碼變得很難讀，不信你可以看看STL的源碼，那是一個(gè)亂啊。使用auto必需一個(gè)初始化值，編譯器可以通過(guò)這個(gè)初始化值推導(dǎo)出類型。因?yàn)閍uto是來(lái)簡(jiǎn)化模板類引入的代碼難讀的問(wèn)題，如上面的示例，iteration這種類型就最適合用auto的，但是，我們不應(yīng)該把其濫用。

比如下面的代碼的可讀性就降低了。因?yàn)椋也恢繮rocessData返回什么？int? bool? 還是對(duì)象？或是別的什么？這讓你后面的程序不知道怎么做。

auto obj = ProcessData(someVariables);

但是下面的程序就沒(méi)有問(wèn)題，因?yàn)閜Object的型別在后面的new中有了。

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

自動(dòng)化推導(dǎo) decltype

關(guān)于 decltype 是一個(gè)操作符，其可以評(píng)估括號(hào)內(nèi)表達(dá)式的類型，其規(guī)則如下：

1. 如果表達(dá)式e是一個(gè)變量，那么就是這個(gè)變量的類型。
2. 如果表達(dá)式e是一個(gè)函數(shù)，那么就是這個(gè)函數(shù)返回值的類型。
3. 如果不符合1和2，如果e是左值，類型為T，那么decltype(e)是T&；如果是右值，則是T。

原文給出的示例如下，我們可以看到，這個(gè)讓的確我們的定義變量省了很多事。

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

還有一個(gè)適合的用法是用來(lái)typedef函數(shù)指針，也會(huì)省很多事。比如：

 decltype(&myfunc) pfunc = 0;

typedef decltype(&A::func1) type;

auto 和 decltype 的差別和關(guān)系

Wikipedia 上是這么說(shuō)的（關(guān)于decltype的規(guī)則見(jiàn)上）

#include <vector>

int main()
{
    const std::vector<int> v(1);
    auto a = v[0];        // a 的類型是 int
    decltype(v[0]) b = 1; // b 的類型是 const int&, 因?yàn)楹瘮?shù)的返回類型是
                          // std::vector<int>::operator[](size_type) const
    auto c = 0;           // c 的類型是 int
    auto d = c;           // d 的類型是 int
    decltype(c) e;        // e 的類型是 int, 因?yàn)?c 的類型是int
    decltype((c)) f = c;  // f 的類型是 int&, 因?yàn)?(c) 是左值
    decltype(0) g;        // g 的類型是 int, 因?yàn)?0 是右值
}

如果auto 和 decltype 在一起使用會(huì)是什么樣子？能看下面的示例，下面這個(gè)示例也是引入decltype的一個(gè)原因——讓C++有能力寫一個(gè) “ forwarding function 模板”，

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

這個(gè)函數(shù)模板看起來(lái)相當(dāng)費(fèi)解，其用到了auto 和 decltype 來(lái)擴(kuò)展了已有的模板技術(shù)的不足。怎么個(gè)不足呢？在上例中，我不知道AddingFunc會(huì)接收什么樣類型的對(duì)象，這兩個(gè)對(duì)象的 + 操作符返回的類型也不知道，老的模板函數(shù)無(wú)法定義AddingFunc返回值和這兩個(gè)對(duì)象相加后的返回值匹配，所以，你可以使用上述的這種定義。

統(tǒng)一的初始化語(yǔ)法

C/C++的初始化的方法比較，C++ 11 用大括號(hào)統(tǒng)一了這些初始化的方法。

比如：POD的類型。

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

關(guān)于POD相說(shuō)兩句，所謂POD就是Plain Old Data，當(dāng)class/struct是極簡(jiǎn)的(trivial)、屬于標(biāo)準(zhǔn)布局(standard-layout)，以及他的所有非靜態(tài)（non-static）成員都是POD時(shí)，會(huì)被視為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的初始化有點(diǎn)怪，比如上例，new A; 和new A(); 是不一樣的，對(duì)于其內(nèi)部的m，前者沒(méi)有被初始化，后者被初始化了（不同 的編譯器行為不一樣，VC++和GCC不一樣）。而非POD的初始化，則都會(huì)被初始化。

從這點(diǎn)可以看出，C/C++的初始化問(wèn)題很奇怪，所以，在C++ 2011版中就做了統(tǒng)一。原文作者給出了如下的示例：

C c {0,0}; //C++11 only. 相當(dāng)于: 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) 555-0987"}};

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

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

Delete 和 Default 函數(shù)

我們知道C++的編譯器在你沒(méi)有定義某些成員函數(shù)的時(shí)候會(huì)給你的類自動(dòng)生成這些函數(shù)，比如，構(gòu)造函數(shù)，拷貝構(gòu)造，析構(gòu)函數(shù)，賦值函數(shù)。有些時(shí)候，我們不想要這些函數(shù)，比如，構(gòu)造函數(shù)，因?yàn)槲覀兿胱鰧?shí)現(xiàn)單例模式。傳統(tǒng)的做法是將其聲明成private類型。

在新的C++中引入了兩個(gè)指示符，delete意為告訴編譯器不自動(dòng)產(chǎn)生這個(gè)函數(shù)，default告訴編譯器產(chǎn)生一個(gè)默認(rèn)的。原文給出了下面兩個(gè)例子：

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

這里，我想說(shuō)一下，為什么我們需要default？我什么都不寫不就是default嗎？不全然是，比如構(gòu)造函數(shù)，因?yàn)橹灰愣x了一個(gè)構(gòu)造函數(shù)，編譯器就不會(huì)給你生成一個(gè)默認(rèn)的了。所以，為了要讓默認(rèn)的和自定義的共存，才引入這個(gè)參數(shù)，如下例所示：

struct SomeType
{
 SomeType() = default; // 使用編譯器生成的默認(rèn)構(gòu)造函數(shù)
 SomeType(OtherType value);
};

關(guān)于delete還有兩個(gè)有用的地方是

1）讓你的對(duì)象只能生成在棧內(nèi)存上：

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

2）阻止函數(shù)的其形參的類型調(diào)用：（若嘗試以 double 的形參調(diào)用 f()，將會(huì)引發(fā)編譯期錯(cuò)誤， 編譯器不會(huì)自動(dòng)將 double 形參轉(zhuǎn)型為 int 再調(diào)用f()，如果傳入的參數(shù)是double，則會(huì)出現(xiàn)編譯錯(cuò)誤）

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

nullptr

C/C++的NULL宏是個(gè)被有很多潛在BUG的宏。因?yàn)橛械膸?kù)把其定義成整數(shù)0，有的定義成 (void*)0。在C的時(shí)代還好。但是在C++的時(shí)代，這就會(huì)引發(fā)很多問(wèn)題。你可以上網(wǎng)看看。這是為什么需要 nullptr 的原因。 nullptr 是強(qiáng)類型的。

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

所以在新版中請(qǐng)以 nullptr 初始化指針。

委托構(gòu)造

在以前的C++中，構(gòu)造函數(shù)之間不能互相調(diào)用，所以，我們?cè)趯戇@些相似的構(gòu)造函數(shù)里，我們會(huì)把相同的代碼放到一個(gè)私有的成員函數(shù)中。

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(); }
};

但是，為了方便并不足讓“委托構(gòu)造”這個(gè)事出現(xiàn)，最主要的問(wèn)題是，基類的構(gòu)造不能直接成為派生類的構(gòu)造，就算是基類的構(gòu)造函數(shù)夠了，派生類還要自己寫自己的構(gòu)造函數(shù)：

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

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

上例中，派生類手動(dòng)繼承基類的構(gòu)造函數(shù)， 編譯器可以使用基類的構(gòu)造函數(shù)完成派生類的構(gòu)造。 而將基類的構(gòu)造函數(shù)帶入派生類的動(dòng)作 無(wú)法選擇性地部分帶入， 所以，要不就是繼承基類全部的構(gòu)造函數(shù)，要不就是一個(gè)都不繼承(不手動(dòng)帶入)。 此外，若牽涉到多重繼承，從多個(gè)基類繼承而來(lái)的構(gòu)造函數(shù)不可以有相同的函數(shù)簽名(signature)。 而派生類的新加入的構(gòu)造函數(shù)也不可以和繼承而來(lái)的基類構(gòu)造函數(shù)有相同的函數(shù)簽名，因?yàn)檫@相當(dāng)于重復(fù)聲明。（所謂函數(shù)簽名就是函數(shù)的參數(shù)類型和順序不）

右值引用和move語(yǔ)義

在老版的C++中，臨時(shí)性變量（稱為右值”R-values”，位于賦值操作符之右）經(jīng)常用作交換兩個(gè)變量。比如下面的示例中的tmp變量。示例中的那個(gè)函數(shù)需要傳遞兩個(gè)string的引用，但是在交換的過(guò)程中產(chǎn)生了對(duì)象的構(gòu)造，內(nèi)存的分配還有對(duì)象的拷貝構(gòu)造等等動(dòng)作，成本比較高。

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

C++ 11增加一個(gè)新的引用（reference）類型稱作右值引用（R-value reference），標(biāo)記為typename &&。他們能夠以non-const值的方式傳入，允許對(duì)象去改動(dòng)他們。這項(xiàng)修正允許特定對(duì)象創(chuàng)造出move語(yǔ)義。

舉例而言，上面那個(gè)例子中，string類中保存了一個(gè)動(dòng)態(tài)內(nèi)存分存的char*指針，如果一個(gè)string對(duì)象發(fā)生拷貝構(gòu)造（如：函數(shù)返回），string類里的char*內(nèi)存只能通過(guò)創(chuàng)建一個(gè)新的臨時(shí)對(duì)象，并把函數(shù)內(nèi)的對(duì)象的內(nèi)存copy到這個(gè)新的對(duì)象中，然后銷毀臨時(shí)對(duì)象及其內(nèi)存。這是原來(lái)C++性能上重點(diǎn)被批評(píng)的事。

能過(guò)右值引用，string的構(gòu)造函數(shù)需要改成“move構(gòu)造函數(shù)”，如下所示。這樣一來(lái)，使得對(duì)某個(gè)stirng的右值引用可以單純地從右值復(fù)制其內(nèi)部C-style的指針到新的string，然后留下空的右值。這個(gè)操作不需要內(nèi)存數(shù)組的復(fù)制，而且空的暫時(shí)對(duì)象的析構(gòu)也不會(huì)釋放內(nèi)存。其更有效率。

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

The C++11 STL中廣泛地使用了右值引用和move語(yǔ)議。因此，很多算法和容器的性能都被優(yōu)化了。

C++ 11 STL 標(biāo)準(zhǔn)庫(kù)

C++ STL庫(kù)在2003年經(jīng)歷了很大的整容手術(shù) Library Technical Report 1 (TR1)。 TR1 中出現(xiàn)了很多新的容器類 (unordered_set, unordered_map, unordered_multiset, 和 unordered_multimap) 以及一些新的庫(kù)支持諸如：正則表達(dá)式， tuples，函數(shù)對(duì)象包裝，等等。 C++11 批準(zhǔn)了 TR1 成為正式的C++標(biāo)準(zhǔn)，還有一些TR1 后新加的一些庫(kù)，從而成為了新的C++ 11 STL標(biāo)準(zhǔn)庫(kù)。這個(gè)庫(kù)主要包含下面的功能：

線程庫(kù)

這們就不多說(shuō)了，以前的STL飽受線程安全的批評(píng)?，F(xiàn)在好 了。C++ 11 支持線程類了。這將涉及兩個(gè)部分：第一、設(shè)計(jì)一個(gè)可以使多個(gè)線程在一個(gè)進(jìn)程中共存的內(nèi)存模型；第二、為線程之間的交互提供支持。第二部分將由程序庫(kù)提供支持。大家可以看看promises and futures，其用于對(duì)象的同步。 async() 函數(shù)模板用于發(fā)起并發(fā)任務(wù)，而 thread_local 為線程內(nèi)的數(shù)據(jù)指定存儲(chǔ)類型。更多的東西，可以查看 Anthony Williams的 Simpler Multithreading in C++0x.

新型智能指針

C++98 的知能指針是 auto_ptr， 在C++ 11中被廢棄了。C++11  引入了兩個(gè)指針類： shared_ptr 和 unique_ptr。 shared_ptr只是單純的引用計(jì)數(shù)指針，unique_ptr 是用來(lái)取代auto_ptr。 unique_ptr 提供 auto_ptr 大部份特性，唯一的例外是 auto_ptr 的不安全、隱性的左值搬移。不像 auto_ptr，unique_ptr 可以存放在 C++0x 提出的那些能察覺(jué)搬移動(dòng)作的容器之中。

為什么要這么干？大家可以看看《More Effective C++》中對(duì) 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()算法，你可以很方便地拷貝數(shù)組。

#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() 可以用來(lái)創(chuàng)建遞增的數(shù)列。如下例所示：

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'} 

總之，看下來(lái)，C++11 還是很學(xué)院派，很多實(shí)用的東西還是沒(méi)有，比如： XML，sockets，reflection，當(dāng)然還有垃圾回收。看來(lái)要等到C++ 20了。呵呵。不過(guò)C++ 11在性能上還是很快。參看 Google’s benchmark tests。原文還引用Stroustrup 的觀點(diǎn)：C++11 是一門新的語(yǔ)言——一個(gè)更好的 C++。

如果把所有的改變都列出來(lái)，你會(huì)發(fā)現(xiàn)真多啊。我估計(jì)C++ Primer那本書的厚度要增加至少30%以上。C++的門檻會(huì)不會(huì)越來(lái)越高了呢？我不知道，但我個(gè)人覺(jué)得這門語(yǔ)言的確是變得越來(lái)越令人望而卻步了。（想起了某人和我說(shuō)的一句話——學(xué)技術(shù)真的是太累了，還是搞方法論好混些？）

（全文完）