源文章來自前C++標(biāo)準(zhǔn)委員會的 Danny Kalev 的 The Biggest Changes in C++11 (and Why You Should Care)，賴勇浩做了一個中文翻譯在這里。所以，我就不翻譯了，我在這里僅對文中提到的這些變化“追問為什么要引入這些變化”的一個探討，只有知道為了什么，用在什么地方，我們才能真正學(xué)到這個知識。而以此你可以更深入地了解這些變化。所以，本文不是翻譯。因為寫得有些倉促，所以難免有問題，還請大家指正。
Lambda 表達(dá)式
Lambda表達(dá)式來源于函數(shù)式編程，說白就了就是在使用的地方定義函數(shù)，有的語言叫“閉包”，如果 lambda 函數(shù)沒有傳回值(例如 void )，其回返類型可被完全忽略。 定義在與 lambda 函數(shù)相同作用域的變量參考也可以被使用。這種的變量集合一般被稱作 closure（閉包）。我在這里就不再講這個事了。表達(dá)式的簡單語法如下，
|
1 |
[capture](parameters)->return_type {body}
|
原文的作者給出了下面的例子：
|
1
2
3
4
5
6
7
8
9
10 |
int main()
{
char s[]="Hello World!";
int Uppercase = 0;
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() 這個玩意最后那個參數(shù)需要一個“函數(shù)對象”，所謂函數(shù)對象，其實是一個class，這個class重載了operator()，于是這個對象可以像函數(shù)的式樣的使用。實現(xiàn)一個函數(shù)對象并不容易，需要使用template，比如下面這個例子就是函數(shù)對象的簡單例子（實際的實現(xiàn)遠(yuǎn)比這個復(fù)雜）：
|
1
2
3
4
5
6
7
8
9 |
template <class T>
class less
{
public:
bool operator()(const T&l, const T&r)const
{
return l < r;
}
};
|
所以，C++引入Lambda的最主要原因就是1）可以定義匿名函數(shù)，2）編譯器會把其轉(zhuǎn)成函數(shù)對象。相信你會和我一樣，會疑問為什么以前STL中的ptr_fun()這個函數(shù)對象不能用？（ptr_fun()就是把一個自然函數(shù)轉(zhuǎn)成函數(shù)對象的）。原因是，ptr_fun() 的局限是其接收的自然函數(shù)只能有1或2個參數(shù)。
那么，除了方便外，為什么一定要使用Lambda呢？它比傳統(tǒng)的函數(shù)或是函數(shù)對象有什么好處呢？我個人所理解的是，這種函數(shù)之年以叫“閉包”，就是因為其限制了別人的訪問，更私有。也可以認(rèn)為他是一次性的方法。Lambda表達(dá)式應(yīng)該是簡潔的，極私有的，為了更易的代碼和更方便的編程。
自動類型推導(dǎo) auto
在這一節(jié)中，原文主要介紹了兩個關(guān)鍵字 auto 和 deltype，示例如下：
|
1
2
3
4 |
auto x=0;
auto c='a';
auto d=0.5;
auto national_debt=14400000000000LL;
|
auto 最大的好處就是讓代碼簡潔，尤其是那些模板類的聲明，比如：STL中的容器的迭代子類型。
|
1 |
vector<int>::const_iterator ci = vi.begin();
|
可以變成：
模板這個特性讓C++的代碼變得很難讀，不信你可以看看STL的源碼，那是一個亂啊。使用auto必需一個初始化值，編譯器可以通過這個初始化值推導(dǎo)出類型。因為auto是來簡化模板類引入的代碼難讀的問題，如上面的示例，iteration這種類型就最適合用auto的，但是，我們不應(yīng)該把其濫用。
比如下面的代碼的可讀性就降低了。因為，我不知道ProcessData返回什么？int? bool? 還是對象？或是別的什么？這讓你后面的程序不知道怎么做。
|
1 |
auto obj = ProcessData(someVariables);
|
但是下面的程序就沒有問題，因為pObject的型別在后面的new中有了。
|
1 |
auto pObject = new SomeType<OtherType>::SomeOtherType();
|
自動化推導(dǎo) decltype
關(guān)于 decltype 是一個操作符，其可以評估括號內(nèi)表達(dá)式的類型，其規(guī)則如下：
- 如果表達(dá)式e是一個變量，那么就是這個變量的類型。
- 如果表達(dá)式e是一個函數(shù)，那么就是這個函數(shù)返回值的類型。
- 如果不符合1和2，如果e是左值，類型為T，那么decltype(e)是T&；如果是右值，則是T。
原文給出的示例如下，我們可以看到，這個讓的確我們的定義變量省了很多事。
|
1
2
3 |
const vector<int> vi;
typedef decltype (vi.begin()) CIT;
CIT another_const_iterator;
|
還有一個適合的用法是用來typedef函數(shù)指針，也會省很多事。比如：
|
1
2
3 |
decltype(&myfunc) pfunc = 0;
typedef decltype(&A::func1) type;
|
auto 和 decltype 的差別和關(guān)系
Wikipedia 上是這么說的（關(guān)于decltype的規(guī)則見上）
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14 |
#include <vector>
int main()
{
const std::vector<int> v(1);
auto a = v[0];
decltype(v[0]) b = 1;
auto c = 0;
auto d = c;
decltype(c) e;
decltype((c)) f = c;
decltype(0) g;
}
|
如果auto 和 decltype 在一起使用會是什么樣子？能看下面的示例，下面這個示例也是引入decltype的一個原因——讓C++有能力寫一個 “ forwarding function 模板”，
|
1
2
3 |
template< typename LHS, typename RHS>
auto AddingFunc(const LHS &lhs, const RHS &rhs) -> decltype(lhs+rhs)
{return lhs + rhs;}
|
這個函數(shù)模板看起來相當(dāng)費解，其用到了auto 和 decltype 來擴展了已有的模板技術(shù)的不足。怎么個不足呢？在上例中，我不知道AddingFunc會接收什么樣類型的對象，這兩個對象的 + 操作符返回的類型也不知道，老的模板函數(shù)無法定義AddingFunc返回值和這兩個對象相加后的返回值匹配，所以，你可以使用上述的這種定義。
統(tǒng)一的初始化語法
C/C++的初始化的方法比較，C++ 11 用大括號統(tǒng)一了這些初始化的方法。
比如：POD的類型。
|
1
2 |
int arr[4]={0,1,2,3};
struct tm today={0};
|
關(guān)于POD相說兩句，所謂POD就是Plain Old Data，當(dāng)class/struct是極簡的(trivial)、屬于標(biāo)準(zhǔn)布局(standard-layout)，以及他的所有非靜態(tài)（non-static）成員都是POD時，會被視為POD。如：
|
1
2
3 |
struct A { int m; };
struct B { ~B(); int m; };
struct C { C() : m() {}; ~C(); int m; };
|
POD的初始化有點怪，比如上例，new A; 和new A(); 是不一樣的，對于其內(nèi)部的m，前者沒有被初始化，后者被初始化了（不同 的編譯器行為不一樣，VC++和GCC不一樣）。而非POD的初始化，則都會被初始化。
從這點可以看出，C/C++的初始化問題很奇怪，所以，在C++ 2011版中就做了統(tǒng)一。原文作者給出了如下的示例：
|
1
2
3
4
5
6
7
8
9 |
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} {}
};
|
容器的初始化：
|
1
2
3
4
5 |
vector<string> vs={ "first", "second", "third"};
map singers =
{ {"Lady Gaga", "+1 (212) 555-7890"},
{"Beyonce Knowles", "+1 (212) 555-0987"}};
|
還支持像Java一樣的成員初始化：
|
1
2
3
4
5
6 |
class C
{
int a=7;
public:
C();
};
|
Delete 和 Default 函數(shù)
我們知道C++的編譯器在你沒有定義某些成員函數(shù)的時候會給你的類自動生成這些函數(shù)，比如，構(gòu)造函數(shù)，拷貝構(gòu)造，析構(gòu)函數(shù)，賦值函數(shù)。有些時候，我們不想要這些函數(shù)，比如，構(gòu)造函數(shù)，因為我們想做實現(xiàn)單例模式。傳統(tǒng)的做法是將其聲明成private類型。
在新的C++中引入了兩個指示符，delete意為告訴編譯器不自動產(chǎn)生這個函數(shù)，default告訴編譯器產(chǎn)生一個默認(rèn)的。原文給出了下面兩個例子：
|
1
2
3
4
5 |
struct A
{
A()=default;
virtual ~A()=default;
};
|
再如delete
|
1
2
3
4
5
6
7 |
struct NoCopy
{
NoCopy & operator =( const NoCopy & ) = delete;
NoCopy ( const NoCopy & ) = delete;
};
NoCopy a;
NoCopy b(a);
|
這里，我想說一下，為什么我們需要default？我什么都不寫不就是default嗎？不全然是，比如構(gòu)造函數(shù)，因為只要你定義了一個構(gòu)造函數(shù)，編譯器就不會給你生成一個默認(rèn)的了。所以，為了要讓默認(rèn)的和自定義的共存，才引入這個參數(shù)，如下例所示：
|
1
2
3
4
5 |
struct SomeType
{
SomeType() = default;
SomeType(OtherType value);
};
|
關(guān)于delete還有兩個有用的地方是
1）讓你的對象只能生成在棧內(nèi)存上：
|
1
2
3 |
struct NonNewable {
void *operator new(std::size_t) = delete;
};
|
2）阻止函數(shù)的其形參的類型調(diào)用：（若嘗試以 double 的形參調(diào)用 f()，將會引發(fā)編譯期錯誤， 編譯器不會自動將 double 形參轉(zhuǎn)型為 int 再調(diào)用f()，如果傳入的參數(shù)是double，則會出現(xiàn)編譯錯誤）
|
1
2 |
void f(int i);
void f(double) = delete;
|
nullptr
C/C++的NULL宏是個被有很多潛在BUG的宏。因為有的庫把其定義成整數(shù)0，有的定義成 (void*)0。在C的時代還好。但是在C++的時代，這就會引發(fā)很多問題。你可以上網(wǎng)看看。這是為什么需要 nullptr 的原因。 nullptr 是強類型的。
|
1
2
3
4
5
6 |
void f(int);
void f(char *);
f(0);
f(nullptr)
|
所以在新版中請以 nullptr 初始化指針。
委托構(gòu)造
在以前的C++中，構(gòu)造函數(shù)之間不能互相調(diào)用，所以，我們在寫這些相似的構(gòu)造函數(shù)里，我們會把相同的代碼放到一個私有的成員函數(shù)中。
|
1
2
3
4
5
6
7
8
9
10 |
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)造”這個事出現(xiàn)，最主要的問題是，基類的構(gòu)造不能直接成為派生類的構(gòu)造，就算是基類的構(gòu)造函數(shù)夠了，派生類還要自己寫自己的構(gòu)造函數(shù)：
|
1
2
3
4
5
6
7
8
9
10
11 |
class BaseClass
{
public:
BaseClass(int iValue);
};
class DerivedClass : public BaseClass
{
public:
using BaseClass::BaseClass;
};
|
上例中，派生類手動繼承基類的構(gòu)造函數(shù)， 編譯器可以使用基類的構(gòu)造函數(shù)完成派生類的構(gòu)造。 而將基類的構(gòu)造函數(shù)帶入派生類的動作 無法選擇性地部分帶入， 所以，要不就是繼承基類全部的構(gòu)造函數(shù)，要不就是一個都不繼承(不手動帶入)。 此外，若牽涉到多重繼承，從多個基類繼承而來的構(gòu)造函數(shù)不可以有相同的函數(shù)簽名(signature)。 而派生類的新加入的構(gòu)造函數(shù)也不可以和繼承而來的基類構(gòu)造函數(shù)有相同的函數(shù)簽名，因為這相當(dāng)于重復(fù)聲明。（所謂函數(shù)簽名就是函數(shù)的參數(shù)類型和順序不）
右值引用和move語義
在老版的C++中，臨時性變量（稱為右值”R-values”，位于賦值操作符之右）經(jīng)常用作交換兩個變量。比如下面的示例中的tmp變量。示例中的那個函數(shù)需要傳遞兩個string的引用，但是在交換的過程中產(chǎn)生了對象的構(gòu)造，內(nèi)存的分配還有對象的拷貝構(gòu)造等等動作，成本比較高。
|
1
2
3
4
5
6 |
void naiveswap(string &a, string &b)
{
string temp = a;
a=b;
b=temp;
}
|
C++ 11增加一個新的引用（reference）類型稱作右值引用（R-value reference），標(biāo)記為typename &&。他們能夠以non-const值的方式傳入，允許對象去改動他們。這項修正允許特定對象創(chuàng)造出move語義。
舉例而言，上面那個例子中，string類中保存了一個動態(tài)內(nèi)存分存的char*指針，如果一個string對象發(fā)生拷貝構(gòu)造（如：函數(shù)返回），string類里的char*內(nèi)存只能通過創(chuàng)建一個新的臨時對象，并把函數(shù)內(nèi)的對象的內(nèi)存copy到這個新的對象中，然后銷毀臨時對象及其內(nèi)存。這是原來C++性能上重點被批評的事。
能過右值引用，string的構(gòu)造函數(shù)需要改成“move構(gòu)造函數(shù)”，如下所示。這樣一來，使得對某個stirng的右值引用可以單純地從右值復(fù)制其內(nèi)部C-style的指針到新的string，然后留下空的右值。這個操作不需要內(nèi)存數(shù)組的復(fù)制，而且空的暫時對象的析構(gòu)也不會釋放內(nèi)存。其更有效率。
|
1
2
3
4
5 |
class string
{
string (string&&);
string&& operator=(string&&);
};
|
The C++11 STL中廣泛地使用了右值引用和move語議。因此，很多算法和容器的性能都被優(yōu)化了。
C++ 11 STL 標(biāo)準(zhǔn)庫
C++ STL庫在2003年經(jīng)歷了很大的整容手術(shù) Library Technical Report 1 (TR1)。 TR1 中出現(xiàn)了很多新的容器類 (unordered_set, unordered_map, unordered_multiset, 和 unordered_multimap) 以及一些新的庫支持諸如：正則表達(dá)式， tuples，函數(shù)對象包裝，等等。 C++11 批準(zhǔn)了 TR1 成為正式的C++標(biāo)準(zhǔn)，還有一些TR1 后新加的一些庫，從而成為了新的C++ 11 STL標(biāo)準(zhǔn)庫。這個庫主要包含下面的功能：
線程庫
這們就不多說了，以前的STL飽受線程安全的批評。現(xiàn)在好 了。C++ 11 支持線程類了。這將涉及兩個部分：第一、設(shè)計一個可以使多個線程在一個進程中共存的內(nèi)存模型；第二、為線程之間的交互提供支持。第二部分將由程序庫提供支持。大家可以看看promises and futures，其用于對象的同步。 async() 函數(shù)模板用于發(fā)起并發(fā)任務(wù)，而 thread_local 為線程內(nèi)的數(shù)據(jù)指定存儲類型。更多的東西，可以查看 Anthony Williams的 Simpler Multithreading in C++0x.
新型智能指針
C++98 的知能指針是 auto_ptr， 在C++ 11中被廢棄了。C++11 引入了兩個指針類： shared_ptr 和 unique_ptr。 shared_ptr只是單純的引用計數(shù)指針，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()。
|
1
2
3
4
5
6
7
8 |
#include <algorithm>
all_of(first, first+n, ispositive());
any_of(first, first+n, ispositive());
none_of(first, first+n, ispositive());
|
使用新的copy_n()算法，你可以很方便地拷貝數(shù)組。
|
1
2
3
4
5 |
#include <algorithm>
int source[5]={0,12,34,50,80};
int target[5];
copy_n(source,5,target);
|
使用 iota() 可以用來創(chuàng)建遞增的數(shù)列。如下例所示：
|
1
2
3
4
5 |
include <numeric>
int a[5]={0};
char c[3]={0};
iota(a, a+5, 10);
iota(c, c+3, 'a');
|
總之，看下來，C++11 還是很學(xué)院派，很多實用的東西還是沒有，比如： XML，sockets，reflection，當(dāng)然還有垃圾回收。看來要等到C++ 20了。呵呵。不過C++ 11在性能上還是很快。參看 Google’s benchmark tests。原文還引用Stroustrup 的觀點：C++11 是一門新的語言——一個更好的 C++。
如果把所有的改變都列出來，你會發(fā)現(xiàn)真多啊。我估計C++ Primer那本書的厚度要增加至少30%以上。C++的門檻會不會越來越高了呢？我不知道，但我個人覺得這門語言的確是變得越來越令人望而卻步了。（想起了某人和我說的一句話——學(xué)技術(shù)真的是太累了，還是搞方法論好混些？）