ticoAg/ChineseCorpus-Kaggle-fanti huggingface dataset:
在上面的簡易例子中，程序員和編譯器都能輕易判斷出幾個變量的類型。而通過使用UL后綴，unsignedVariable的類型自動成為unsigned long。最后，動態創建對象時已經要在 new 后輸入類型，此時使用 auto 就能省略掉累贅的MyPackage::Object*聲明。
using namespace std::placeholders;
auto someStrangeCallableType = std::bind(&SomeFunction, _2, _1, someObject);
auto otherVariable = 5;
上面的例子中說明auto有利于C++支援函數式編程。這里注意std::bind也是C++11從Boost C++ Libraries中引入的模版函數。std::bind實現了偏函數，在上面的例子中它將函數SomeFunction的第三個參數綁定為someObject，并將第一和第二個參數的在參數列表中的順序倒轉，由此生成一個函數對象someStrangeCallableType。該函數對象的類型非常復雜，但編譯器卻能輕易地將其推導出來。
除此之外，decltype能夠被用來在編譯期決定一個表示式的型別。舉例：
int someInt;
decltype(someInt) otherIntegerVariable = 5;
decltype和auto一起使用會更為有用，因為auto變數的型別只有編譯器知道。然而decltype對於那些大量運用運算子重載和特化的型別的程式碼的表示也非常有用。
auto對於減少冗贅的程式碼也很有用。舉例而言，程式員不用寫像下面這樣：
for (vector::const_iterator itr = myvec.cbegin; itr != myvec.cend; ++itr)
而可以用更簡短的
for (auto itr = myvec.cbegin; itr != myvec.cend; ++itr)
由于"myvec"實現了begin/end迭代器，C++11提供了基于范圍的循環來大幅度省略代碼。
for (auto& x : myvec)
這項差異隨著程式員開始嵌套容器而更為顯著，雖然在這種情況下typedef是一個減少程式碼的好方法。
decltype所表示的型別可以和auto推導出來的不同。
const std::vector v(1);
auto a = v0；// a為int型別
decltype（v0) b = 0;   // b為const int&型別，即
// std::vector::operator（size_type）const的回返型別
auto c = 0;         // c為int型別
auto d = c;         // d為int型別
decltype(c) e;      // e為int型別，c實體的型別
decltype((c)) f = e; // f為int&型別，因為（c）是左值
decltype(0) g;      // g為int型別，因為0是右值
for語句將允許簡單的範圍迭代：
int my_array5 = {1, 2, 3, 4, 5};
// double the value of each element in my_array:
for (int &x : my_array)
x *= 2;
// similar but also using type inference for array elements
for (auto &x : my_array) {
上面for述句的第一部份定義被用來做範圍迭代的變量，就像被宣告在一般for迴圈的變量一樣，其作用域僅只於迴圈的範圍。而在":"之後的第二區塊，代表將被迭代的範圍。這種for語句還可以用于C型數組，初始化列表，和任何定義了begin和end來返回首尾迭代器的類型。
在標準C++，特別是當使用C++標準程式庫演算法函式諸如sort和find，使用者經常希望能夠在演算法函式呼叫的附近定義一個臨時的述部函式（又稱謂詞函數，predicate function）。由于語言本身允許在函式內部定義類別，可以考慮使用函數對象，然而這通常既麻煩又冗贅，也阻礙了程式碼的流程。此外，標準C++不允許定義於函式內部的類別被用於模板，所以前述的作法是不可行的。
C++11對lambda（即匿名函數）的支援可以解決上述問題。
一個lambda函式可以用如下的方式定義：
(int x, int y) { return x + y; }
這個不具名函式的回返型別是decltype(x+y)。只有在lambda函式符合"return ''expression''"的形式下，它的回返型別才能被忽略。在前述的情況下，lambda函式僅能為一個述句。
在一個更為複雜的例子中，回返型別可以被明確的指定如下：
(int x, int y) -> int { int z = x + y; return z + x; }
本例中，一個暫時的變數z被建立用來儲存中間結果。如同一般的函式，z的值不會保留到下一次該不具名函式再次被呼叫時。
如果lambda函式沒有傳回值（例如void），其回返型別可被完全忽略。
定義在與lambda函式相同作用域的變數參考也可以被使用。這種的變數集合一般被稱作closure（閉包）。
// 沒有定義任何變量。使用未定義變量會引發錯誤。
x, &y // x以傳值方式傳入（默認），y以引用方式傳入。
&     // 任何被使用到的外部變量都隱式地以引用方式加以引用。
=     // 任何被使用到的外部變量都隱式地以傳值方式加以引用。
&, x  // x顯式地以傳值方式加以引用。其余變量以引用方式加以引用。
=, &z // z顯式地以引用方式加以引用。其余變量以傳值方式加以引用。
closure被定義與使用如下：
std::vector someList;
int total = 0;
std::for_each(someList.begin, someList.end, &total(int x) {
total += x;
上例可計算someList元素的總和並將其印出。變數total是lambda函式closure的一部分，同時它以引用方式被傳遞入謂詞函數，因此它的值可被lambda函式改變。
若不使用引用的符號''&''，則代表變數以傳值的方式傳入lambda函式。讓使用者可以用這種表示法明確區分變數傳遞的方法：傳值，或是傳參考。由於lambda函式可以不在被宣告的地方就地使用（如置入std::function物件中）；
這種情況下，若變數是以傳參考的方式連結到closure中，是無意義甚至是危險的行為。
若lambda函式只在定義的作用域使用，則可以用&宣告lambda函式，代表所有引用到stack中的變數，都是以參考的方式傳入，不必一一顯式指明：
std::for_each(someList.begin, someList.end, &(int x) {
變數傳入lambda函式的方式可能隨實做有所變化，一般期望的方法是lambda函式能保留其作用域函式的stack指標，藉此存取區域變數。
若使用=而非&，則代表所有的參考的變數都是傳值使用。
對於不同的變數，傳值或傳參考可以混和使用。比方說，使用者可以讓所有的變數都以傳參考的方式使用，但帶有一個傳值使用的變數：
int value = 5;
&, value(int x) { total += (x * value); };
total是傳參考的方式傳入lambda函式，而value則是傳值。
若一個lambda函式被定義於某類別的成員函式中，則可以使用該類別物件的參考，並且能夠存取其內部的成員。
(SomeType *typePtr) { typePtr->SomePrivateMemberFunction; };
這只有當該lambda函式創建的作用域是在SomeType的成員函式內部時才能運作。
在成員函式中指涉物件的this指標，必須要顯式的傳入lambda函式，否則成員函式中的lambda函式無法使用任何該物件的變數或函式。
this { this->SomePrivateMemberFunction; };
若是lambda函式使用&或是=的形式，this在lambda函式即為可見。
lambda函式是編譯器從屬型別的函式物件；這種型別名稱只有編譯器自己能夠使用。如果使用者希望將lambda函式作為參數傳入，該型別必須是模版型別，或是必須創建一個std::function去獲取lambda的值。使用auto關鍵字讓我們能夠儲存lambda函式：
auto myLambdaFunc = this { this->SomePrivateMemberFunction; };
auto myOnheapLambdaFunc = new auto(= { /*...*/ });
lambda函數按照值方式捕獲的環境中的變量，是不能修改的。否則，編譯器會報錯：“by copy capture cannot be modified in a non-mutable lambda”。其值是lambda函數定義時捕獲的值，不再改變。如果在lambda函數定義時加上mutable關鍵字，則該捕獲的傳值變量是可以修改的，對同一個lambda函數的隨后調用也會累加影響該捕獲的傳值變量，但對外界環境中被捕獲的那個變量無影響。例如：
size_t t = 9;
auto f = t mutable {return t; };
標準C函式宣告語法對於C語言已經足夠。演化自C的C++除了C的基礎語法外，又擴充額外的語法。然而，當C++變得更為複雜時，它暴露出許多語法上的限制，特別是針對函數模板的宣告。下面的範例，不是合法的C++03：
Ret AddingFunc(const LHS &lhs, const RHS &rhs) {return lhs + rhs;} //Ret的型別必須是(lhs+rhs)的型別
Ret的型別由LHS與RHS相加之後的結果的型別來決定。即使使用C++11新加入的decltype來宣告AddingFunc的返回型別，依然不可行。
decltype(lhs+rhs) AddingFunc(const LHS &lhs, const RHS &rhs) {return lhs + rhs;} //不合法的C++11
不合法的原因在於lhs及rhs在定義前就出現了。直到剖析器解析到函數原型的後半部，lhs與rhs才是有意義的。
針對此問題，C++11引進一種新的函數定義與聲明的語法：
auto AddingFunc(const LHS &lhs, const RHS &rhs) -> decltype(lhs+rhs) {return lhs + rhs;}
這種語法也能套用到一般的函數定義與聲明：
struct SomeStruct
auto FuncName(int x, int y) -> int;
auto SomeStruct::FuncName(int x, int y) -> int
return x + y;
關鍵字auto的使用與其在自動型別推導代表不同的意義。
在C++03中，建構式不能呼叫其它的建構式；每個建構式必須自己初始化所有的成員或是呼叫一個共用的成員函式。基礎類別的建構式不能夠直接作為衍生類別的建構式；就算基類的建構式已經足夠，每個衍伸的類別仍必須實做自己的建構式。類別中non-constant的資料成員不能夠在宣告的地方被初始化，它們只能在建構式中被初始化。
C++11將會提供這些問題的解決方案。
C++11允許建構式呼叫其他建構式，這種做法稱作委託（delegation）構造。僅僅只需要加入少量的代碼，就能讓數個建構式之間達成功能復用（reuse）。Java以及C?都有提供這種功能。C++11語法如下：
class SomeType {
int number;
string name;
SomeType( int i, string& s ) : number(i), name(s){}
SomeType( )           : SomeType( 0, "invalid" ){}
SomeType( int i )     : SomeType( i, "guest" ){}
SomeType( string& s ) : SomeType( 1, s ){ PostInit; }
class DCExcept{
DCExcept(double d)
try : DCExcept(1, d){
C++03中，建構式執行結束代表物件建構完成；
而允許使用轉接建構式的C++11則是以"任何"一個建構式結束代表建構完成。使用委托的建構式，函式本體中的代碼將於被委托的建構式完成後繼續執行（如上例的PostInit）。若基類使用了委托建構式，則衍生類別的建構式會在"所有"基底類別的建構式都完成後，才會開始執行。
C++11允許衍生類別手動繼承基底類別的建構式，編譯器可以使用基底類別的建構式完成衍生類別的建構。而將基類的建構式帶入衍生類的動作，無法選擇性地部分帶入，要不就是繼承基類全部的建構式，要不就是一個都不繼承（不手動帶入）。此外，若牽涉到多重繼承，從多個基底類別繼承而來的建構式不可以有相同的函式簽名（signature）。而衍生類別的新加入的建構式也不可以和繼承而來的基底建構式有相同的函式簽名，因為這相當於重複宣告。
class BaseClass
BaseClass(int iValue);
class DerivedClass : public BaseClass
using BaseClass::BaseClass;
此語法等同於DerivedClass宣告一個DerivedClass(int)的建構式。同時也因為DerivedClass有了一個繼承而來的建構式，所以不會有預設建構式。
另一方面，C++11可以使用以下的語法完成數據成員的原地（in-place)初始化：
class SomeClass
SomeClass {}
explicit SomeClass(int iNewValue) : iValue(iNewValue) {}
int iValue = 5;
若是建構式中沒有設定iValue的初始值，則會採用類別定義中的成員初始化，令iValue初值為5。在上例中，無參數版本的建構式，iValue便採用預設所定義的值；而帶有一個整數參數的建構式則會以指定的值完成初始化。
成員初始化除了上例中的賦值形式（使用"="），也可以採用建構式以及統一形的初始化（uniform initialization，使用"{}"）。
在C++裡，在子類別中容易意外的重載虛函數。舉例來說：
struct Base {
virtual void some_func;
struct Derived : Base {
void some_func;
Derived::some_func的真實意圖為何？程序員真的試圖重載該虛函數，或這只是意外？這也可能是base的維護者在其中加入了一個與Derived::some_func同名且擁有相同簽名的虛函式。
另一個可能的狀況是，當基類中的虛函式的簽名被改變，子類中擁有舊簽名的函式就不再重載該虛函式。因此，如果程序員忘記修改所有子類，執行期將不會正確呼叫到該虛函式正確的實現。
C++11將加入支援用來防止上述情形產生，並在編譯期而非執行期捕獲此類錯誤。為保持向後兼容，此功能將是選擇性的。其語法如下：
virtual void some_func(float);
virtual void some_func(int) override;   // 錯誤格式：Derive::some_func並沒有override Base::some_func
virtual void some_func(float) override; // OK：顯式改寫
編譯器會檢查基底類別是否存在一虛擬函數，與衍生類別中帶有聲明override的虛擬函數，有相同的函數簽名（signature）；若不存在，則會回報錯誤。
C++11也提供指示字final，用來避免類別被繼承，或是基底類別的函數被改寫：
struct Base1 final { };
struct Derived1 : Base1 { }; // 錯誤格式：class Base1已標明為final
struct Base2 {
virtual void f final;
struct Derived2 : Base2 {
void f; // 錯誤格式：Base2::f已標明為final
以上的範例中，virtual void f final;聲明一新的虛擬函數，同時也表明禁止衍生函數改寫原虛擬函數。
override與final都不是語言關鍵字（keyword），只有在特定的位置才有特別含意，其他地方仍舊可以作為一般指示字（identifier）使用。
早在1972年，C語言誕生的初期，常數0帶有常數及空指標的雙重身分。
C使用preprocessor macro NULL表示空指標，讓NULL及0分別代表空指標及常數0。
NULL可被定義為((void*)0)或是0。
C++並不採用C的規則，不允許將void*隱式轉換為其他型別的指標。為了使代碼char* c = NULL;能通過編譯，NULL只能定義為0。這樣的決定使得函數多載無法區分代碼的語意：
void foo(char *);
void foo(int);
void foo(nullptr_t);
C++建議NULL應當定義為0，所以foo(NULL);將會呼叫foo(int)，這並不是程序員想要的行為，也違反了代碼的直觀性。0的歧義在此處造成困擾。
C++11引入了新的關鍵字來代表空指標常數：nullptr，將空指標和整數0的概念拆開。
nullptr的型別為nullptr_t，能隱式轉換為任何指標或是成員指標的型別，也能和它們進行相等或不等的比較。而nullptr不能隱式轉換為整數，也不能和整數做比較。
為了向下相容，0仍可代表空指標常數。
char* pc = nullptr;     // OK
int * pi = nullptr;     // OK
int    i = nullptr;     // error
bool   b = nullptr;     // OK
foo(pc);           // 調用foo(char *), 而不是 foo(int);
foo(nullptr);      // 調用foo(nullptr_t);
值得注意的是上面的 foo(nullptr_t) 被隱式轉換為 foo(char *) 只會發生在該函數不存在其它的指針類型重載（比如 foo(int*), foo(MyClass*)等）時候，否則就會產生歧義錯誤（可以通過顯示聲明一個 foo(nullptr_t) 來消除該歧義）。
在C++11的標準類型頭文件中，nullptr_t 類型應該被聲明為：
typedef decltype(nullptr) nullptr_t;
typedef int nullptr_t; //  C++11之前的標準需要定義 NULL 為 0
typedef void *nullptr_t; // ANSI C 定義 NULL 為 ((void*)0)
在C++03中，列舉型別不是型別安全的。列舉型別被視為整數，這使得兩種不同的列舉型別之間可以進行比較。C++03唯一提供的安全機制是一個整數或一個枚舉型值不能隱式轉換到另一個列舉別型。此外，列舉所使用整數型別及其大小都由實作方法定義，皆無法明確指定。最後，列舉的名稱全數暴露於枚舉類型的作用域中，因此兩個不同的列舉，不可以有相同的列舉名。（好比 enum Side{ Right, Left }; 和 enum Thing{ Wrong, Right }; 不能一起使用。）
C++11引進了一種特別的"列舉類"，可以避免上述的問題。使用enum class的語法來宣告：
enum class myEnumeration
Val3 = 100,
Val4 /* = 101 */,
此種列舉為型別安全的。列舉類別不能隱式地轉換為整數；也無法與整數數值做比較。（表示式Enumeration::Val4 == 101會觸發編譯期錯誤）。
列舉類別所使用型別必須顯式指定。在上面的範例中，使用的是預設型別int，但也可以指定其他型別：
enum class Enum2 : unsigned int {Val1, Val2};
列舉類別的作用域（scoping）不包含枚舉值的名字。使用枚舉值的名字，必須明確限定于其所屬的枚舉類型。例如，前述列舉類別Enum2，Enum2::Val1是有意義的表示法，而單獨的Val1則否。
此外，C++11允許為傳統的列舉指定使用型別：
enum Enum3 : unsigned long {Val1 = 1, Val2};
列舉名Val1定義於Enum3的列舉範圍中（Enum3::Val1），但為了向后相容性，
Val1仍然可以於所屬枚舉類型所在的作用域中單獨使用。
在C++11中，列舉類別的前置聲明（forward declaration）也是可行的，只要使用可指定型別的新式列舉即可。之前的C++無法寫出列舉的前置聲明，是由於無法確定列舉變數所佔的空間大小，C++11解決了這個問題：
enum Enum1;                     // C++與C++11中不合法;無法判別大小
enum Enum2 : unsigned int;      // 合法的C++11
enum class Enum3;               // 合法的C++11，列舉類別使用預設型別int
enum class Enum4: unsigned int; // 合法的C++11
enum Enum2 : unsigned short;    // 不合法的C++11，Enum2已被聲明為unsigned int
C++03的剖析器一律將">>"視為右移運算子。但在嵌套樣板定義式中，絕大多數的場合其實都代表兩個連續右角括號。為了避免剖析器誤判，撰碼時不能把右角括號連著寫。
C++11變更了剖析器的解讀規則；當遇到連續的右角括號時，會在合理的情況下將右尖括號解析為樣板引數的結束符號。給使用>,>=,>>的表達式加上圓括號，可以避免其與圓括號外部的左尖括號相匹配：
template class SomeType;
std::vector2>> x1;   // 解讀為std::vector of "SomeType 2>"，
// 非法的表示式，整數1被轉換為bool型別true
std::vector2)>> x1; // 解讀為std::vector of "SomeType",
// 合法的C++11表示式，(1>2)被轉換為bool型別false
C++98引入了關鍵字explicit來避免用戶自定的單引數建構式被當成隱式型別轉換子。但是，卻沒有限制明確定義的類型轉換函數。比方說，一個smart pointer類別具有一個operator bool，被定義成若該smart pointer不為null則傳回true，反之傳回false。遇到這樣的代碼時：if(smart_ptr_variable)，編譯器可以藉由operator bool隱式轉換成布林值，和測試原生指標的方法一樣。但是這類隱式轉換同樣也會發生在非預期之處。由於C++的bool型別也是算術型別，能隱式換為整數甚至是浮點數。拿物件轉換出的布林值做布林運算以外的數學運算，往往不是程序員想要的。
在C++11中，關鍵字explicit修飾符也能套用到型別轉換函數上。如同建構式一樣，它能避免型別轉換函數被隱式轉換調用。但C++11特別指定，在if條件式、迴圈、邏輯運算等需要布林值的地方，將其作為顯式類型轉換，因此即使對應的類型轉換函數被explicit修飾也可以調用。這主要為了解決 safe bool問題。
在進入這個主題之前，各位應該先弄清楚「模板」和「型別」本質上的不同。class template (類別模板，是模板)是用來產生template class（模板類別，是型別）。在C++03中，typedef可定義模板類別一個新的型別名稱，但是不能夠使用typedef來定義模板的別名。舉例來說：
typedef SomeType TypedefName; // 在C++03是不合法的
這不能夠通過編譯。
為了定義模板的別名，C++11將會增加以下的語法：
using也能在C++11中定義一般型別的別名，等同typedef：
typedef void (*PFD)(double);		// 傳統語法
using PFD = void (*)(double);		// 新增語法
C++98支持類模板的模板參數默認值，不支持函數模板的模板參數默認值。C++11可以支持函數模板的模板參數默認值。類模板的模板參數默認值需要從右到左依次出現；函數模板的默認模板參數沒有此約束。
void DefParm(int m = 3) {} // c++98編譯通過，c++11編譯通過
class DefClass {};        // c++98編譯通過，c++11編譯通過
void DefTempParm {};    // c++98編譯失敗，c++11編譯通過
//以下為C++11編譯：
class DefClass1 {};
class DefClass2 {};  // ERROR: 無法通過編譯：因為模板參數的默認值沒有遵循“由右往左”的規則
class DefClass3 {};
class DefClass4 {};  // ERROR: 無法通過編譯：因為模板參數的默認值沒有遵循“由右往左”的規則
void DefFunc1(T1 a, T2 b) {}; // OK 函數模板不用遵循“由右往左”的規則
void DefFunc2(T a) {};  // OK 函數模板不用遵循“由右往左”的規則
//通常，如果能夠從函數實參中推導出類型的話，那么默認模板參數就不會被使用，反之，默認模板參數則可能會被使用：
void f(T t = 0, U u = 0) {};
void g
f(1, 'c'); // f(1, 'c')
f(1);      // f(1, 0), 使用了默認模板參數double
f;       // 錯誤: T無法被推導出來
f;  // f(0, 0), 使用了默認模板參數double
f; // f(0, 0)
在C++03中，並非任意的-{A|zh-hans:類型; zh-hant:型別}-都能做為union的成員。比方說，帶有non-trivial -{A|zh-hans:構造函數; zh-hant:建構式}-的型別就不能是union的成員。在新的標準裡，移除了所有對union的使用限制，除了其成員仍然不能是-{A|zh-hans:引用; zh-hant:參照}-型別。這一改變使得union更強大，更有用，也易於使用。
但是如果union成員具有非平凡的 特殊成員函數，則編譯器不會為union生成對應的特殊成員函數，必須手工定義。
以下為C++11中union使用的簡單-{A|zh-hans:樣例; zh-hant:範例}-：
struct Point
Point {}
Point(int x, int y): x_(x), y_(y) {}
int x_, y_;
union U
int z;
double w;
Point p;  // 在C++03中是不合法（point有一non-trivial建構式），但是在C++11是合法的
U {} // 由于 Point 成員的存在，必須要定義一個構造函數
U(const Point& pt) : p(pt) {} // 通過初始化列表構造 Point 對象
U& operator=(const Point& pt) { new (&p) Point(pt); return *this; } // 通過原地new方式賦值構造Point對象
這一改變僅放寬union的使用限制，不會影響既有的舊代碼。
這些特性讓C++語言能夠做一些以前做不到的，或者極其復雜的，或者需求一些不可移植的庫的事情。
在C++11之前，不論是類模板或是-{A|zh-hans:函數; zh-hant:函式}-模板，都只能按其被聲明時所指定的樣子，接受一組固定數目的模板參數；C++11加入新的表示法，允許任意-{A|zh-hans:個數; zh-hant:長度}-、任意-{A|zh-hans:類別; zh-hant:型別}-的模板參數，不必在定義時將參數的個數固定。
template class tuple;
模板類tuple的-{A|zh-hans:對象; zh-hant:物件}-，能接受不限個數的typename作為它的模板-{A|zh-hans:形參; zh-hant:引數}-：
class tuple, std::map>> someInstanceName;
-{zh-hans:實參; zh-hant:引數}-的個數也可以是0，所以class tuple someInstanceName這樣的定義也是可以的。
若不希望產生-{zh-hans:實參; zh-hant:引數}-個數為0的不定長參數模板，則可以採用以下的定義：
不定長參數模板也能運用到模板函式上。傳統C中的printf函式，雖然也能達成不定長度的引數的調用，但其並非型別安全。以下的範例中，C++11除了能定義型別安全的-{A|zh-hans:變長參數函數; zh-hant:不定長引數函式}-外，還能讓類似printf的函式能自然地處理非內建型別的物件。除了在模板參數中能使用''...''表示不定長模板參數外，函數參數也使用同樣的表示法代表不定長參數。
template void printf(const std::string &strFormat, Params... parameters);
其中，Params與parameters分別代表模板與函式的-{A|zh-hans:變長參數; zh-hant:不定長參數}-集合，稱之為參數包（parameter pack）。參數包必須要和-{A|zh-hans:運算符; zh-hant:算子}-"..."搭配使用，避免語法上的歧義。
不定長參數模板中，不定長參數包無法如同一般參數在類或函式中使用；
因此典型的手法是以遞迴的方法取出可用參數，參看以下的C++11 printf範例：
void printf(const char *s)
while (*s)
if (*s == '%' && *(++s) != '%')
throw std::runtime_error("invalid format string: missing arguments");
void printf(const char* s, T value, Args... args)
printf會不斷地遞迴調用自身：函式參數包args...在調用時，會被模板型別匹配分離為T value和Args... args。直到args...變為空參數，則會與簡單的printf(const char *s)形成匹配，結束遞迴。
另一個例子為計算模板參數的長度，這裡使用相似的技巧展開模板參數包Args...：
struct Count{};
struct count {
static const int value = 0;
static const int value = 1 + count::value;
-{zh-hans:雖然沒有一個簡潔的機制能夠對變長參數模板中的值進行迭代; zh-hant:雖然沒有很簡單的機制能個別依序處理變長參數模板的參數}-，但使用算子"..."還能在代碼各處對參數包施以更複雜的展開操作。舉例來說，一個模板類的定義：
template  class ClassName : public BaseClasses...
ClassName (BaseClasses&&... baseClasses) : BaseClasses(baseClasses)... {}
BaseClasses...會被展開成類別ClassName的基底類；ClassName的-{A|zh-hans:構造函數; zh-hant:建構式}-需要所有-{A|zh-hans:基類; zh-hant:基底類}-的右值-{A|zh-hans:引用; zh-hant:參照}-，而每一個基底類都是以傳入的參數做初始化（BaseClasses(baseClasses)...）。
在函式模板中，不定長參數可以和右值參照搭配，達成引數的完美轉送（perfect forwarding）：
template struct SharedPtrAllocator
template std::shared_ptr ConstructWithSharedPtr(Args&&... params)
return std::shared_ptr(new TypeToConstruct(std::forward(params)...));
參數包parms可展開為TypeToConstruct建構式的引數。-{A|zh-hans:表達式; zh-hant:表示式}-std::forward(params)可將引數的型別-{A|zh-hans:信息; zh-hant:資訊}-保留（利用右值參照），傳入建構式。而算子"..."則能將前述的表示式套用到每一個參數包中的參數。這種工廠函式（factory function）的手法，使用std::shared_ptr管理配置物件的記憶體，避免了不當使用所產生的記憶體洩漏（memory leaks）。
此外，不定長參數的數量可以藉以下的語法得知：
template struct SomeStruct
static const int size = sizeof...(Args);
SomeStruct::size是2，而SomeStruct::size會是0。（sizeof...(Args)的結果是編譯期常數。）
標準C++提供了兩種字串字面值。第一種，包含有雙引號，產生以空字元結尾的const char陣列。第二種有著前標L，產生以空字元結尾的const wchar_t陣列，其中wchar_t代表寬字元。對於Unicode編碼的支援尚付闕如。
為了加強C++編譯器對Unicode的支援，型別char的定義被修改為其大小至少能夠儲存UTF-8的8位元編碼，並且能夠容納編譯器的基本字元集的任何成員。
C++11將支援三種Unicode編碼方式：UTF-8，UTF-16，和UTF-32。除了上述char定義的變更，C++11將增加兩種新的字元型別：char16_t和char32_t。它們各自被設計用來儲存UTF-16以及UTF-32的字元。
以下展示如何產生使用這些編碼的字串字面值：
u8"I'm a UTF-8 string."
u"This is a UTF-16 string."
U"This is a UTF-32 string."
第一個字串的型別是通常的const char；第二個字串的型別是const char16_t；第三個字串的型別是const char32_t。
當建立Unicode字串字面值時，可以直接在字串內插入Unicode codepoints。C++11提供了以下的語法：
u8"This is a Unicode Character: \u2018."
u"This is a bigger Unicode Character: \u2018."
U"This is a Unicode Character: \U00002018."
在'\u'之後的是16個位元的十六進位數值；它不需要'0x'的前標。識別字'\u'代表了一個16位元的Unicode codepoint；如果要輸入32位元的codepoint，使用'\U'和32個位元的十六進位數值。只有有效的Unicode codepoints能夠被輸入。舉例而言，codepoints在範圍U+D800—U+DFFF之間是被禁止的，它們被保留給UTF-16編碼的surrogate pairs。
有時候避免手動將字串換碼也是很有用的，特別是在使用XML檔案或是一些腳本語言的字面值的時候。C++11將提供raw（原始）字串字面值：
R"(The String Data \ Stuff " )"
R"delimiter(The String Data \ Stuff " )delimiter"
在第一個例子中，任何包含在(&nbsp;)括號（標準已經從改為）當中的都是字串的一部分。其中"和\字元不需要經過轉義。在第二個例子中，"delimiter(開始字串，只有在遇到)delimiter"才代表結束。其中delimiter可以是最多16個字符的任意的字串（包含空字符串），但不能包含空格、控制字符和'('、')'、'\'。原始字符串允許使用者使用圓括號(,)，例如R"delimiter((a-z))delimiter"等價于"(a-z)"。原始字串字面值能夠和寬字面值或是Unicode字面值結合：
u8R"XXX(I'm a "raw UTF-8" string.)XXX"
// uR"*@(This is a "raw UTF-16" string.)*@"    //visual studio not support '@'
uR"*(This is a "raw UTF-16" string.)*"
UR"(This is a "raw UTF-32" string.)"
標準C++提供了數種字面值。字元"12.5"是能夠被編譯器解釋為數值12.5的double型別字面值。然而，加上"f"的後置，像是"12.5f"，則會產生數值為12.5的float型別字面值。之前的C++規範中字面值的修飾符是固定的，C++代碼不能創立新的字面修飾符。
C++11開放使用者定義新的字面修飾符（literal modifier），利用自訂的修飾符完成由字面值建構物件。
字面值轉換可以定義為兩個階段：原始與轉換後（raw與cooked）。原始字面值指特定類型的字符序列，而轉換後的字面值則代表另一種型別。如字面值1234，原始字面值是'1', '2', '3', '4'的字符序列；而轉換後的字面值是整數值1234。另外，字面值0xA轉換前是序列'0', 'x', 'A'；轉換後代表整數值10。
C++標準委員會計劃統一對多緒編程的支援。
這將涉及兩個部分：第一、設計一個可以使多個線程在一個進程中共存的內存模型；第二、為線程之間的互動提供支援。第二部分將由程式庫提供支持，更多請看緒程支援。
在多個線程可能會訪問相同內存的情形下，由一個內存模型對它們進行調度是非常有必要的。遵守模型規則的程序是被保證正確運行的，但違反規則的程序會發生不可預料的行為，這些行為依賴于編譯器的最佳化和記憶體一致性的問題。
在多緒環境下，讓各緒程擁有各自的變數是很普遍的。這已經存在於函式的區域變數，但是對於全域和靜態變數都還不行。
新的''thread_local''存儲期限（在現行的''static''、''dynamic''和''automatic''之外）被作為下個標準而提出。緒程區域的存儲期限會藉由存儲指定字thread_local來表明。
static物件(生命週期為整個程式的執行期間)的存儲期限可以被thread-local給替代。就如同其他使用static存儲期的變數，thread-local物件能夠以建構式初始化並以解構式摧毀。
在傳統C++中，若使用者沒有提供，則編譯器會自動為物件生成預設建構式(default constructor)、複製建構式（copy constructor），賦值運算子（copy assignment operator operator=）以及解構式（destructor）。另外，C++也為所有的類別定義了數個全域算子（如operator delete及operator new）。當使用者有需要時，也可以提供自訂的版本改寫上述的函式。
問題在於原先的c++無法精確地控制這些預設函數的生成。比方說，要讓類別不能被拷貝，必須將複製建構式與賦值運算子宣告為private，並不去定義它們。嘗試使用這些未定義的函式會導致編譯期或連結期的錯誤。但這種手法並不是一個理想的解決方案。
此外，編譯器產生的預設建構式與使用者定義的建構式無法同時存在。若使用者定義了任何建構式，編譯器便不會生成預設建構式；
但有時同時帶有上述兩者提供的建構式也是很有用的。目前並沒有顯式指定編譯器產生預設建構式的方法。
C++11允許顯式地表明採用或拒用編譯器提供的內建函式。例如要求類別帶有預設建構式，可以用以下的語法：
struct SomeType
SomeType = default; // 預設建構式的顯式聲明
SomeType(OtherType value);
另一方面，也可以禁止編譯器自動產生某些函式。如下面的例子，類別不可複製：
struct NonCopyable
NonCopyable & operator=(const NonCopyable&) = delete;
NonCopyable(const NonCopyable&) = delete;
NonCopyable = default;
禁止類別以operator new配置記憶體：
struct NonNewable
void *operator new(std::size_t) = delete;
此種物件只能生成於stack中或是當作其他類別的成員，它無法直接配置於heap之中，除非使用了與平臺相關，不可移植的手法。（使用placement new算子雖然可以在用戶自配置的記憶體上呼叫物件建構式，但在此例中其他形式的new算子一併被上述的定義遮蔽（"name hiding"），所以也不可行。）
= delete的聲明（同時也是定義）也能適用於非內建函式，禁止成員函式以特定的引數呼叫：
struct NoDouble
void f(int i);
void f(double) = delete;
若嘗試以double的引數呼叫f，將會引發編譯期錯誤，編譯器不會自動將double引數轉型為int再呼叫f。若要徹底的禁止以非int的引數呼叫f，可以將= delete與模板相結合：
struct OnlyInt
template void f(T) = delete;
在32位元系統上，一個long long int是保有至少64個有效位元的整數型別。C99將這個型別引入了標準C中，目前大多數的C++編譯器也支援這種型別。C++11將把這種型別添加到標準C++中。
C++提供了兩種方法測試assertion（聲明）：巨集assert以及前處理器指令#error。但是這兩者對於模版來說都不合用。巨集在執行期測試assertion，而前處理器指令則在前置處理時測試assertion，這時候模版還未能具現化。所以它們都不適合來測試牽扯到模板參數的相關特性。
新的機能會引進新的方式可以在編譯期測試assertion，只要使用新的關鍵字static_assert。宣告採取以下的形式：
static_assert( ''constant-expression'', ''error-message'' ) ;
這裡有一些如何使用static_assert的例子：
static_assert( 3.14
struct Check
static_assert( sizeof(int)
當常數表示式值為false時，編譯器會產生相應的錯誤訊息。第一個例子是前處理器指令#error的替代方案；第二個例子會在每個模板類別Check生成時檢查assertion。
靜態assertion在模板之外也是相當有用的。例如，某個演算法的實作依賴於long long型別的大小比int還大，這是標準所不保證的。這種假設在大多數的系統以及編譯器上是有效的，但不是全部。
C++98, sizeof只能對實例的變量或者類的靜態成員進行操作，不能對類的非靜態成員進行操作，若要想達成對類的非靜態成員的操作，可以用如下ugly方式, 0強轉成對象的指針，并解析訪問對應非靜態成員變量。
struct SomeType { OtherType member; };
sizeof( (SomeType *)(0) ->member); //C++98
sizeof(SomeType::member); // 直接由SomeType型別取得非靜態成員的大小，C++03不行。C++11允許
這會傳回OtherType的大小。C++03並不允許這樣做，所以會引發編譯錯誤。C++11將會允許這種使用。
是否會自動回收那些無法被使用到（unreachable）的動態分配物件由實作決定。
參見頭文件中的幾個函數：
* void declare_reachable(void* p);
* template T* undeclare_reachable(T *p) noexcept;
* void declare_no_pointers(char*p ,size_t n)noexcept;
* void undeclare_no_pointers(char*p ,size_t n) noexcept;
C++11標準程式庫有數個新機能。其中許多可以在現行標準下實作，而另外一些則依賴於（或多或少）新的C++11核心語言機能。
新的程式庫的大部分被定義於''C++標準委員會的Library Technical Report''（稱TR1），於2005年發布。各式TR1的完全或部分實作目前提供在命名空間std::tr1。C++11會將其移置於命名空間std之下。
目前的標準庫能受益於C++11新增的一些語言特性。舉例來說，對於大部份的標準庫容器而言，像是搬移內含大量元素的容器，或是容器之內對元素的搬移，基於右值引用（Rvalue reference）的move建構子都能優化前述動作。在適當的情況下，標準庫元件將可利用C++11的語言特性進行升級。這些語言特性包含但不局限以下所列：
* 右值引用和其相關的move支援
* 支援UTF-16編碼，和UTF-32字元集
* 變長參數模板（與右值引用搭配可以達成完美轉發（perfect forwarding））
此外，自C++標準化之後已經過許多年。現有許多代碼利用到了標準庫;這同時揭露了部份的標準庫可以做些改良。其中之一是標準庫的記憶體配置器（allocator）。C++11將會加入一個基於作用域模型的記憶體配置器來支援現有的模型。
雖然C++11會在語言的定義上提供一個記憶體模型以支援執行緒，但執行緒的使用主要將以C++11標準函式庫的方式呈現。
C++11標準函式庫會提供類別thread（std::thread）。若要執行一個執行緒，可以建立一個類別thread的實體，其初始參數為一個函式物件，以及該函式物件所需要的參數。透過成員函式std::thread::join對執行緒會合的支援，一個執行緒可以暫停直到其它執行緒執行完畢。若有底層平臺支援，成員函式std::thread::native_handle將可提供對原生執行緒物件執行平臺特定的操作。
對於執行緒間的同步，標準函式庫將會提供適當的互斥鎖（像是std::mutex，std::recursive_mutex等等）和條件變數（std::condition_variable和std::condition_variable_any）。前述同步機制將會以RAII鎖（std::lock_guard和std::unique_lock）和鎖相關演算法的方式呈現，以方便程式員使用。
對於要求高效能，或是極底層的工作，有時或甚至是必須的，我們希望執行緒間的通訊能避免互斥鎖使用上的開銷。以原子操作來存取記憶體可以達成此目的。針對不同情況，我們可以透過顯性的記憶體屏障改變該存取記憶體動作的可見性。
對於執行緒間非同步的傳輸，C++11標準函式庫加入了以及std::packaged_task用來包裝一個會傳回非同步結果的函式呼叫。因為缺少結合數個future的功能，和無法判定一組promise集合中的某一個promise是否完成，futures此一提案因此而受到了批評。
更高級的執行緒支援，如執行緒池，已經決定留待在未來的Technical Report加入此類支援。更高級的執行緒支援不會是C++11的一部份，但設想是其最終實現將建立在目前已有的執行緒支援之上。
std::async提供了一個簡便方法以用來執行執行緒，並將執行緒綁定在std::future。使用者可以選擇一個工作是要多個執行緒上非同步的執行，或是在一個執行緒上執行並等待其所需要的資料。預設的情況，實作可以根據底層硬體選擇前面兩個選項的其中之一。另外在較簡單的使用情形下，實作也可以利用執行緒池提供支援。
多元組是一個內由數個異質物件以特定順序排列而成的資料結構。多元組可被視為是struct其資料成員的一般化。
由TR1演進而來的C++11多元組型別將受益於C++11某些特色像是可變參數模板。TR1版本的多元組型別對所能容納的物件個數會因實作而有所限制，且實作上需要用到大量的巨集技巧。相反的，C++11版本的多元組型基本上於對其能容納的物件個數沒有限制。然而，編譯器對於模板實體化的遞迴深度上的限制仍舊影響了元組型別所能容納的物件個數（這是無法避免的情況）；C++11版本的多元組型不會把這個值讓使用者知道。
使用可變參數模板，多元組型別的宣告可以長得像下面這樣：
template  class tuple;
底下是一個多元組型別的定義和使用情況：
typedef std::tuple  test_tuple;
long lengthy = 12;
test_tuple proof (18, 6.5, lengthy, "Ciao!");
lengthy = std::get(proof);  // 將proof的第一個元素賦值給lengthy（索引從零開始起跳）
std::get(proof) = " Beautiful!";  // 修改proof的第四個元素
我們可以定義一個多元組型別物件proof而不指定其內容，前提是proof裡的元素其型別定義了預設建構子（default constructor）。此外，以一個多元組型別物件賦值給另一個多元組型別物件是可能的，但只有在以下情況：若這兩個多元組型別相同，則其內含的每一個元素其型別都要定義拷貝建構子（copy constructor）；否則的話，賦值操作符右邊的多元組其內含元素的型別必須能轉換成左邊的多元組其對應的元素型別，又或者賦值操作符左邊的多元組其內含元素的型別必須定義適當的建構子。
std::tuple t1;
std::tuple t2 ('X', 2, "Hola!");
t1 = t2 ;  // 可行。前兩個元素會作型別轉換，
// 第三個字串元素可由'const char *'所建構。
多元組類型物件的比較運算是可行的（當它們擁有同樣數量的元素）。此外，C++11提供兩個表達式用來檢查多元組類型的一些特性（僅在編譯期做此檢查）。
*std::tuple_size::value回傳多元組T內的元素個數，
*std::tuple_element::type回傳多元組T內的第I個元素的型別
在過去，不斷有要求想將雜湊表（無序關聯式容器）引進標準庫。只因為時間上的限制，雜湊表才沒有被標準庫所採納。雖然，雜湊表在最糟情況下（如果出現許多衝突（collision）的話）在效能上比不過平衡樹。但實際運用上，雜湊表的表現則較佳。
因為標準委員會還看不到有任何機會能將開放定址法標準化，所以目前衝突僅能透過鏈地址法（linear chaining）的方式處理。為避免與第三方函式庫發展的雜湊表發生名稱上的衝突，字首將採用unordered而非hash。
函式庫將引進四種雜湊表，其中差別在於底下兩個特性：是否接受具相同鍵值的項目（Equivalent keys），以及是否會將鍵值映射到相對應的資料（Associated values）。
接受相同鍵值
std::unordered_multiset
std::unordered_multimap
上述的類別將滿足對一個容器類別的要求，同時也提供存取其中元素的成員函式：insert，erase，begin，end。
雜湊表不需要對現有核心語言做擴展（雖然雜湊表的實作會利用到C++11新的語言特性），只會對標頭檔做些許擴展，並引入和兩個標頭檔。對於其它現有的類別不會有任何修改。同時，雜湊表也不會依賴其它標準庫的擴展功能。
過去許多或多或少標準化的程式庫被建立用來處理正規表示式。有鑑於這些演算法的使用非常普遍，因此標準程式庫將會包含他們，並使用各種物件導向語言的潛力。
這個新的程式庫，被定義於標頭檔，由幾個新的類別所組成：
* 正規表示式（樣式）以樣板類basic_regex的實體表示
* 樣式匹配的情況以樣板類match_results的實體表示
函式regex_search是用來搜尋樣式；若要搜尋並取代，則要使用函式regex_replace，該函式會回傳一個新的字串。演算法regex_search和regex_replace接受一個正規表示式（樣式）和一個字串，並將該樣式匹配的情況儲存在struct match_results。
底下描述了match_results的使用情況：
const char *reg_esp = " ,.\\t\\n;:" ;  // 分隔字元列表
std::regex rgx(reg_esp) ;  // 'regex'是樣板類'basic_regex'以型別為'char'
//  的參數具現化的實體
std::cmatch match ;  // 'cmatch'是樣板類match_results'以型別為'const char *'
// '的參數具現化的實體
const char *target = "Polytechnic University of Turin " ;
// 辨別所有被分隔字元所分隔的字
if( regex_search( target, match, rgx ) )
// 若此種字存在
const size_t n = match.size;
for( size_t a = 0 ; a
注意雙反斜線的使用，因為C++將反斜線作為跳脫字元使用。但C++11的raw string可以用來避免此一問題。函式庫不需要改動到現有的標頭檔，同時也不需要對現有的語言作擴展。
這些指針是由TR1智能指標演變而來。注意! 智能指針是類別而非一般指標。
shared_ptr是一引用計數（reference-counted）指針，其行為與一般C++指標極為相似。在TR1的實作中，缺少了一些一般指針所擁有的特色，像是別名或是指標運算。C++11新增前述特色。
一個shared_ptr只有在已經沒有任何其它shared_ptr指向其原本所指向物件時，才會銷毀該物件。
一個weak_ptr指向的是一個被shared_ptr所指向的物件。該weak_ptr可以用來決定該物件是否已被銷毀。weak_ptr不能被解參考;想要存取其內部所保存的指針，只能透過shared_ptr。有兩種方法可達成此目的。第一，類別shared_ptr有一個以weak_ptr為參數的建構子。第二，類別weak_ptr有一個名為lock的成員函式，其返回值為一個shared_ptr。weak_ptr並不擁有它所指向的物件，因此不影響該物件的銷毀與否。
底下是一個shared_ptr的使用範例：
int main( )
std::shared_ptr p_first(new double) ;
std::shared_ptr p_copy = p_first ;
*p_copy = 21.2;
}  // 此時'p_copy'會被銷毀，但動態分配的double不會被銷毀。
return 0;  // 此時'p_first'會被銷毀，動態分配的double也會被銷毀（因為不再有指針指向它）。
auto_ptr將會被C++標準所廢棄，取而代之的是unique_ptr。unique_ptr提供auto_ptr大部份特性，唯一的例外是auto_ptr的不安全、隱性的左值搬移。不像auto_ptr，unique_ptr可以存放在C++11提出的那些能察覺搬移動作的容器之中。
C標準庫允許使用rand函數來生成偽隨機數。不過其演算法則取決於各程式庫開發者。C++直接從C繼承了這部份，但是C++11將會提供產生偽亂數的新方法。
C++11的隨機數功能分為兩部分：第一，一個亂數生成引擎，其中包含該生成引擎的狀態，用來產生亂數。第二，一個分布，這可以用來決定產生亂數的範圍，也可以決定以何種分布方式產生亂數。亂數生成物件即是由亂數生成引擎和分布所構成。
不同於C標準庫的rand;針對產生亂數的機制，C++11將會提供三種演算法，每一種演算法都有其強項和弱項：
整數/浮點數
linear_congruential
subtract_with_carry
mersenne_twister