轉：c++ 11 新特性

聲 明：本文源自 Danny Kalev 在 2011 年 6 月 21 日發表的《The Biggest Changes in C++11(and Why You Should Care)》一文，幾乎全部內容都搬了過來，但不是全文照譯，有困惑之處，請參詳原文（http://www.softwarequalityconnection.com/2011/06/the-biggest-changes-in-c11-and-why-you-should-care/ ）。
注：做者 Danny Kalev 曾是 C++ 標準委員會成員。

Lambda 表達式

Lambda 表達式的形式是這樣的：

 

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

其中 [&Uppercase] 中的 & 的意義是 lambda 函數體要獲取一個 Uppercase 引用，以便可以改變它的值，若是沒有 &，那就 Uppercase 將以傳值的形式傳遞過去。

自動類型推導和 decltype

在 C++03 中，聲明對象的同時必須指明其類型，其實大多數狀況下，聲明對象的同時也會包括一個初始值，C++11 在這種狀況下就可以讓你聲明對象時再也不指定類型了：

 

auto x=0; //0 是 int 類型，因此 x 也是 int 類型
auto c='a'; //char
auto d=0.5; //double
auto national_debt=14400000000000LL;//long long

這個特性在對象的類型很大很長的時候頗有用，如：

void func(const vector<int> &vi)
{
  vector<int>::const_iterator ci=vi.begin();
}

那個迭代器能夠聲明爲：

auto ci=vi.begin();

C++11 也提供了從對象或表達式中「俘獲」類型的機制，新的操做符 decltype 能夠從一個表達式中「俘獲」其結果的類型並「返回」：

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

 

統一的初始化語法

C++ 最少有 4 種不一樣的初始化形式，如括號內初始化，見：

std::string s("hello");
int m=int(); //default initialization

還有等號形式的：

std::string s="hello";
int x=5;

對於 POD 集合，又能夠用大括號：

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

最後還有構造函數的成員初始化：

struct S {
 int x;
 S(): x(0) {} };

這麼多初始化形式，不只菜鳥會搞得很頭大，高手也吃不消。更慘的是 C++03 中竟然不能初始化 POD 數組的類成員，也不能在使用 new[] 的時候初始 POD 數組，操蛋啊！C++11 就用大括號一統天下了：

class C
{
int a;
int b;
public:
 C(int i, int j);
};
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, 初始化數組成員
};

還有一大好事就是對於容器來講，終於能夠擺脫 push_back() 調用了，C++11中能夠直觀地初始化容器了：

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

而類中的數據成員初始化也獲得了支持：

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

 

deleted 函數和 defaulted 函數

像如下形式的函數：

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

叫作 defaulted 函數，=default; 指示編譯器生成該函數的默認實現。這有兩個好處：一是讓程序員輕鬆了，少敲鍵盤，二是有更好的性能。
與 defaulted 函數相對的就是 deleted 函數：

int func()=delete;

這貨有一大用途就是實現 noncopyabe 防止對象拷貝，要想禁止拷貝，用 =deleted 聲明一下兩個關鍵的成員函數就能夠了：

struct NoCopy
{
    NoCopy & operator =( const NoCopy & ) = delete;
    NoCopy ( const NoCopy & ) = delete;
};
NoCopy a;
NoCopy b(a); //編譯錯誤，拷貝構造函數是 deleted 函數

 

nullptr

nullptr 是一個新的 C++ 關鍵字，它是空指針常量，它是用來替代高風險的 NULL 宏和 0 字面量的。nullptr 是強類型的：

void f(int); //#1
void f(char *);//#2
//C++03
f(0); //調用的是哪一個 f?
//C++11
f(nullptr) //毫無疑問，調用的是 #2

全部跟指針有關的地方均可以用 nullptr，包括函數指針和成員指針：

const char *pc=str.c_str(); //data pointers
if (pc!=nullptr)
  cout<<pc<<endl;
int (A::*pmf)()=nullptr; //指向成員函數的指針
void (*pmf)()=nullptr; //指向函數的指針

 

委託構造函數

C++11 中構造函數能夠調用同一個類的另外一個構造函數：

class M //C++11 delegating constructors
{
 int x, y;
 char *p;
public:
 M(int v) : x(v), y(0),  p(new char [MAX])  {} //#1 target
 M(): M(0) {cout<<"delegating ctor"<<end;} //#2 delegating

#2 就是所謂的委託構造函數，調用了真正的構造函數 #1。

右值引用

在 C++03 中的引用類型是隻綁定左值的，C++11 引用一個新的引用類型叫右值引用類型，它是綁定到右值的，如臨時對象或字面量。
增長右值引用的主要緣由是爲了實現 move 語義。與傳統的拷貝不一樣，move 的意思是目標對象「竊取」原對象的資源，並將源置於「空」狀態。當拷貝一個對象時，其實代價昂貴且無必要，move 操做就能夠替代它。如在 string 交換的時候，使用 move 意義就有巨大的性能提高，如原方案是這樣的：

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

這種方案很傻很天真，很慢，由於須要申請內存，而後拷貝字符，而 move 就只須要交換兩個數據成員，無須申請、釋放內存和拷貝字符數組：

void moveswapstr(string& empty, string & filled)
{
//pseudo code, but you get the idea
 size_t sz=empty.size();
 const char *p= empty.data();
//move filled's resources to empty
 empty.setsize(filled.size());
 empty.setdata(filled.data());
//filled becomes empty
 filled.setsize(sz);
 filled.setdata(p);
}

要實現支持 move 的類，須要聲明 move 構造函數和 move 賦值操做符，以下：

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

C++11 的標準庫普遍使用 move 語義，不少算法和容器都已經使用 move 語義優化過了。

C++11 的標準庫

除 TR1 包含的新容器（unordered_set, unordered_map, unordered_multiset, 和unordered_multimap），還有一些新的庫，如正則表達式，tuple，函數對象封裝器等。下面介紹一些 C++11 的標準庫新特性：

線程庫

從程序員的角度來看，C++11 最重要的特性就是併發了。C++11 提供了 thread 類，也提供了 promise 和 future 用以併發環境中的同步，用 async() 函數模板執行併發任務，和 thread_local 存儲聲明爲特定線程獨佔的數據，這裏（http://www.devx.com/SpecialReports/Article/38883）有一個簡單 的 C++11 線程庫教程（英文）。

新的智能指針類

C++98 定義的惟一的智能指針類 auto_ptr 已經被棄用，C++11 引入了新的智能針對類 shared_ptr 和 unique_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];
//從 source 拷貝 5 個元素到 target
copy_n(source,5,target);

iota() 算法能夠用來建立遞增序列，它先把初值賦值給 *first，而後用前置 ++ 操做符增加初值並賦值到給下一個迭代器指向的元素，以下：

#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 API，socket，GUI、反射——以及自動垃圾收集。然而現有特性已經讓 C++ 更安全、高效（是的，效率更高了，能夠參見 Google 的 基準測試結果http://www.itproportal.com/2011/06/07/googles-rates-c-most- complex-highest-performing-language/）以及更加易於學習和使用。

若是以爲 C++ 變化太大了，沒必要驚恐，花點時間來學習就行了。可能在你融會貫通新特性之後，你會贊成 Stroustrup 的觀點：C++11 是一門新的語言——一個更好的 C++。