stanford-oval/wikipedia huggingface dataset:
C++11
核心語言使用性的加強 > 無限制的unions

在C++03中，並非任意的型別都能做為union的成員。比方說，帶有non-trivial 建構式的型別就不能是union的成員。在新的標準裡，移除了所有对union的使用限制，除了其成員仍然不能是引用型別。這一改變使得union更強大，更有用，也易於使用。
但是如果union成员具有非平凡的特殊成员函数（页面存档备份，存于），则编译器不会为union生成对应的特殊成员函数，必须手工定义。
以下為C++11中union使用的簡單範例：
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之前，不論是类模板或是函式模板，都只能按其被声明時所指定的样子，接受一組固定数目的模板参数；C++11加入新的表示法，允许任意長度、任意型別的模板参数，不必在定義時將參數的个数固定。
template<typename... Values> class tuple;
模板類tuple的物件，能接受不限個數的typename作為它的模板引數：
class tuple<int, std::vector<int>, std::map<std::string, std::vector<int>>> someInstanceName;
的个数也可以是0，所以class tuple<> someInstanceName这样的定义也是可以的。
若不希望產生个数為0的不定長參數模板，則可以採用以下的定義：
template<typename First, typename... Rest> class tuple;
不定長參數模板也能運用到模板函式上。傳統C中的printf函式，雖然也能達成不定長度的引數的調用，但其並非型別安全。以下的範例中，C++11除了能定義型別安全的不定長引數函式外，還能讓类似printf的函式能自然地處理非內建型別的物件。除了在模板參數中能使用...表示不定長模板參數外，函數參數也使用同樣的表示法代表不定長參數。
template<typename... Params> void printf(const std::string &strFormat, Params... parameters);
其中，Params與parameters分別代表模板與函式的不定長參數集合，稱之為參數包（parameter pack）。參數包必須要和算子"..."搭配使用，避免語法上的歧義。
不定長參數模板中，不定長參數包無法如同一般參數在類或函式中使用；
因此典型的手法是以遞迴的方法取出可用參數，參看以下的C++11 printf範例：
void printf(const char *s)
{
  while (*s)
  {
    if (*s == '%' && *(++s) != '%')
      throw std::runtime_error("invalid format string: missing arguments");
    std::cout << *s++;
  }
}

template<typename T, typename... Args>
void printf(const char* s, T value, Args... args)
{
  while (*s)
  {
    if (*s == '%' && *(++s) != '%')
    {
      std::cout << value;
      printf(*s ? ++s : s, args...); // 即便当*s == 0也会产生调用，以检测更多的类型参数。
      return;
    }
    std::cout << *s++;
  }
  throw std::logic_error("extra arguments provided to printf");
}
printf會不斷地遞迴調用自身：函式參數包args...在調用時，會被模板型別匹配分離為T value和Args... args。直到args...變為空參數，則會與簡單的printf(const char *s)形成匹配，結束遞迴。
另一個例子為計算模板參數的長度，這裡使用相似的技巧展開模板參數包Args...：
template<typename... args>
struct Count{};
template<>
struct count<> {
    static const int value = 0;
};

template<typename T, typename... Args>
struct count<T, Args...> { 
    static const int value = 1 + count<Args...>::value;
};
，但使用算子"..."還能在代碼各處對參數包施以更複雜的展開操作。舉例來說，一個模板類的定義：
template <typename... BaseClasses> class ClassName : public BaseClasses...
{
public:

   ClassName (BaseClasses&&... baseClasses) : BaseClasses(baseClasses)... {}
}
BaseClasses...會被展開成類別ClassName的基底類；ClassName的建構式需要所有基底類的右值引用，而每一個基底類都是以傳入的參數做初始化（BaseClasses(baseClasses)...）。
在函式模板中，不定長參數可以和右值參照搭配，達成引數的完美轉送（perfect forwarding）：
template<typename TypeToConstruct> struct SharedPtrAllocator
{
  template<typename... Args> std::shared_ptr<TypeToConstruct> ConstructWithSharedPtr(Args&&... params)
  {
    return std::shared_ptr<TypeToConstruct>(new TypeToConstruct(std::forward<Args>(params)...));
  }
}
參數包parms可展開為TypeToConstruct建構式的引數。表示式std::forward<Args>(params)可將引數的型別信息保留（利用右值參照），傳入建構式。而算子"..."則能將前述的表示式套用到每一個參數包中的參數。這種工廠函式（factory function）的手法，使用std::shared_ptr管理配置物件的記憶體，避免了不當使用所產生的記憶體洩漏（memory leaks）。
此外，不定長參數的數量可以藉以下的語法得知：
template<typename ...Args> struct SomeStruct
{
  static const int size = sizeof...(Args);
}
SomeStruct<Type1, Type2>::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"
在第一個例子中，任何包含在( )括號（標準已經從[]改為()）當中的都是字串的一部分。其中"和\字元不需要經過转义。在第二個例子中，"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。
核心語言能力的提升 > 多工記憶體模型

参见：内存模型(computing)
C++标准委员会计划统一对多緒編程的支援。
这将涉及两个部分：第一、设计一个可以使多个线程在一个进程中共存的内存模型；第二、为线程之間的互動提供支援。第二部分将由程式庫提供支持，更多请看緒程支援。
在多个线程可能会访问相同内存的情形下，由一个内存模型对它们进行调度是非常有必要的。遵守模型规则的程序是被保证正确运行的，但违反规则的程序会发生不可预料的行为，这些行为依赖于编译器的最佳化和記憶體一致性的问题。
核心語言能力的提升 > thread-local的存儲期限

在多緒環境下，讓各緒程擁有各自的變數是很普遍的。這已經存在於函式的區域變數，但是對於全域和靜態變數都還不行。
新的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
{
  void f(int i);
  template<class T> void f(T) = delete;
};
核心語言能力的提升 > long long int型別

在32位元系統上，一個long long int是保有至少64個有效位元的整數型別。C99將這個型別引入了標準C中，目前大多數的C++編譯器也支援這種型別。C++11將把這種型別添加到標準C++中。
核心語言能力的提升 > 靜態assertion

C++提供了兩種方法測試assertion（聲明）：巨集assert以及前處理器指令#error。但是這兩者對於模版來說都不合用。巨集在執行期測試assertion，而前處理器指令則在前置處理時測試assertion，這時候模版還未能具現化。所以它們都不適合來測試牽扯到模板參數的相關特性。
新的機能會引進新的方式可以在編譯期測試assertion，只要使用新的關鍵字static_assert。宣告採取以下的形式：
static_assert( constant-expression, error-message ) ;
這裡有一些如何使用static_assert的例子：
static_assert( 3.14 < GREEKPI && GREEKPI < 3.15, "GREEKPI is inaccurate!" ) ;
template< class T >
struct Check
{
  static_assert( sizeof(int) <= sizeof(T), "T is not big enough!" ) ;
} ;
當常數表示式值為false時，編譯器會產生相應的錯誤訊息。第一個例子是前處理器指令#error的替代方案；第二個例子會在每個模板類別Check生成時檢查assertion。
靜態assertion在模板之外也是相當有用的。例如，某個演算法的實作依賴於long long型別的大小比int還大，這是標準所不保證的。這種假設在大多數的系統以及編譯器上是有效的，但不是全部。
核心語言能力的提升 > 允許sizeof運算子作用在類別的資料成員上，無須明確的物件

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）的動態分配物件由實作決定。
参见<memory>头文件中的几个函数：
void declare_reachable(void* p);
template<class T> 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++標準程式庫的變更

C++11標準程式庫有數個新機能。其中許多可以在現行標準下實作，而另外一些則依賴於（或多或少）新的C++11核心語言機能。
新的程式庫的大部分被定義於C++標準委員會的Library Technical Report（稱TR1），於2005年發布。各式TR1的完全或部分實作目前提供在命名空間std::tr1。C++11會將其移置於命名空間std之下。
C++標準程式庫的變更 > 標準庫元件上的升級

目前的標準庫能受益於C++11新增的一些語言特性。舉例來說，對於大部份的標準庫容器而言，像是搬移內含大量元素的容器，或是容器之內對元素的搬移，基於右值引用（Rvalue reference）的move建構子都能優化前述動作。在適當的情況下，標準庫元件將可利用C++11的語言特性進行升級。這些語言特性包含但不局限以下所列：
右值引用和其相關的move支援
支援UTF-16編碼，和UTF-32字元集
變長參數模板（與右值引用搭配可以達成完美转发（perfect forwarding））
編譯期常數表達式
Decltype
顯式型別轉換子
使用或禁用物件的預設函式
此外，自C++標準化之後已經過許多年。現有許多代碼利用到了標準庫;這同時揭露了部份的標準庫可以做些改良。其中之一是標準庫的記憶體配置器（allocator）。C++11將會加入一個基於作用域模型的記憶體配置器來支援現有的模型。
C++標準程式庫的變更 > 執行緒支援

雖然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。使用者可以選擇一個工作是要多個執行緒上非同步的執行，或是在一個執行緒上執行並等待其所需要的資料。預設的情況，實作可以根據底層硬體選擇前面兩個選項的其中之一。另外在較簡單的使用情形下，實作也可以利用執行緒池提供支援。
C++標準程式庫的變更 > 多元組型別

多元組是一個內由數個異質物件以特定順序排列而成的資料結構。多元組可被視為是struct其資料成員的一般化。
由TR1演進而來的C++11多元組型別將受益於C++11某些特色像是可变參數模板。TR1版本的多元組型別對所能容納的物件個數會因實作而有所限制，且實作上需要用到大量的巨集技巧。相反的，C++11版本的多元組型基本上於對其能容納的物件個數沒有限制。然而，編譯器對於模板實體化的遞迴深度上的限制仍舊影響了元組型別所能容納的物件個數（這是無法避免的情況）；C++11版本的多元組型不會把這個值讓使用者知道。
使用可变參數模板，多元組型別的宣告可以長得像下面這樣：
template <class ...Types> class tuple;
底下是一個多元組型別的定義和使用情況：
typedef std::tuple <int, double, long &, const char *> test_tuple;
long lengthy = 12;
test_tuple proof (18, 6.5, lengthy, "Ciao!");

lengthy = std::get<0>(proof);  // 將proof的第一個元素賦值給lengthy（索引從零開始起跳）
std::get<3>(proof) = " Beautiful!";  // 修改proof的第四個元素
我們可以定義一個多元組型別物件proof而不指定其內容，前提是proof裡的元素其型別定義了預設建構子（default constructor）。此外，以一個多元組型別物件賦值給另一個多元組型別物件是可能的，但只有在以下情況：若這兩個多元組型別相同，則其內含的每一個元素其型別都要定義拷貝建構子（copy constructor）；否則的話，賦值操作符右邊的多元組其內含元素的型別必須能轉換成左邊的多元組其對應的元素型別，又或者賦值操作符左邊的多元組其內含元素的型別必須定義適當的建構子。
std::tuple< int , double, string       > t1;
std::tuple< char, short , const char * > t2 ('X', 2, "Hola!");
t1 = t2 ;  // 可行。前兩個元素會作型別轉換，
           // 第三個字串元素可由'const char *'所建構。
多元組類型物件的比較運算是可行的（當它們擁有同樣數量的元素）。此外，C++11提供兩個表達式用來檢查多元組類型的一些特性（僅在編譯期做此檢查）。
std::tuple_size<T>::value回傳多元組T內的元素個數，
std::tuple_element<I, T>::type回傳多元組T內的第I個元素的型別
C++標準程式庫的變更 > 雜湊表

在過去，不斷有要求想將雜湊表（無序關聯式容器）引進標準庫。只因為時間上的限制，雜湊表才沒有被標準庫所採納。雖然，雜湊表在最糟情況下（如果出現許多衝突（collision）的話）在效能上比不過平衡樹。但實際運用上，雜湊表的表現則較佳。
因為標準委員會還看不到有任何機會能將開放定址法標準化，所以目前衝突僅能透過鏈地址法（linear chaining）的方式處理。為避免與第三方函式庫發展的雜湊表發生名稱上的衝突，字首將採用unordered而非hash。
函式庫將引進四種雜湊表，其中差別在於底下兩個特性：是否接受具相同鍵值的項目（Equivalent keys），以及是否會將鍵值映射到相對應的資料（Associated values）。
| 雜湊表類型 | 有無關聯值 | 接受相同鍵值 |
| --- | --- | --- |
std::unordered_set: 否
| std::unordered_multiset | 否 | 是 |
| std::unordered_map | 是 | 否 |
std::unordered_multimap: 是
上述的類別將滿足對一個容器類別的要求，同時也提供存取其中元素的成員函式：insert，erase，begin，end。
雜湊表不需要對現有核心語言做擴展（雖然雜湊表的實作會利用到C++11新的語言特性），只會對標頭檔<functional>做些許擴展，並引入<unordered_set>和<unordered_map>兩個標頭檔。對於其它現有的類別不會有任何修改。同時，雜湊表也不會依賴其它標準庫的擴展功能。
C++標準程式庫的變更 > 正規表示式

過去許多或多或少標準化的程式庫被建立用來處理正規表示式。有鑑於這些演算法的使用非常普遍，因此標準程式庫將會包含他們，並使用各種物件導向語言的潛力。
這個新的程式庫，被定義於<regex>標頭檔，由幾個新的類別所組成：
正規表示式（樣式）以樣板類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 < n ; a++ )
  {
    string str( match[a].first, match[a].second ) ;
    cout << str << "\n" ;
  }
}
注意雙反斜線的使用，因為C++將反斜線作為跳脫字元使用。但C++11的raw string可以用來避免此一問題。函式庫<regex>不需要改動到現有的標頭檔，同時也不需要對現有的語言作擴展。
C++標準程式庫的變更 > 通用智能指針

這些指針是由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<double> p_first(new double) ;

    {
        std::shared_ptr<double> 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++標準程式庫的變更 > 可扩展的随机数功能

C标准库允许使用rand函数来生成伪随机数。不過其演算法則取決於各程式庫開发者。C++直接從C繼承了這部份，但是C++11將會提供產生偽亂數的新方法。
C++11的随机数功能分为两部分：第一，一個亂數生成引擎，其中包含該生成引擎的狀態，用來產生亂數。第二，一個分布，這可以用來決定產生亂數的範圍，也可以決定以何種分布方式產生亂數。亂數生成物件即是由亂數生成引擎和分布所構成。
不同於C標準庫的rand;針對產生亂數的機制，C++11將會提供三種演算法，每一種演算法都有其強項和弱項：
| 樣板類 | 整數/浮點數 | 品質 | 速度 | 狀態數* |
| --- | --- | --- | --- | --- |
| linear_congruential | 整數 | 低 | 中等[來源請求] | 1 |
| subtract_with_carry | 兩者皆可 | 中等 | 快 | 25 |
| mersenne_twister | 整數 | 佳 | 快 | 624 |
C++11將會提供一些標準分布：uniform_int_distribution（離散型均勻分佈），bernoulli_distribution(伯努利分布），geometric_distribution（幾何分佈），poisson_distribution（卜瓦松分佈），binomial_distribution（二項分佈），uniform_real_distribution（離散型均勻分佈)，exponential_distribution（指数分布），normal_distribution（常態分佈）和gamma_distribution（伽玛分布）。
底下描述一個亂數生成物件如何由亂數生成引擎和分布構成：
std::uniform_int_distribution<int> distribution(0, 99); // 以離散型均勻分佈方式產生int亂數，範圍落在0到99之間
std::mt19937 engine; // 建立亂數生成引擎
auto generator = std::bind(distribution, engine); // 利用bind將亂數生成引擎和分布組合成一個亂數生成物件
int random = generator();  // 產生亂數
C++標準程式庫的變更 > 包装引用

我們可以透過實體化樣板類reference_wrapper得到一個包装引用（wrapper reference）。包装引用類似於一般的引用。對於任意物件，我們可以透過模板類ref得到一個包装引用（至於constant reference則可透過cref得到）。
當樣板函式需要形參的引用而非其拷貝，這時包装引用就能派上用場：
// 此函數將得到形參'r'的引用並對r加一
void f (int &r)  { r++; }

// 樣板函式
template<class F, class P> void g (F f, P t)  { f(t); }

int main()
{
    int i = 0 ;
    g (f, i) ;  // 實體化'g<void (int &r), int>' 
                // 'i'不會被修改
    std::cout << i << std::endl;  // 輸出0

    g (f, std::ref(i));  // 實體化'g<void(int &r),reference_wrapper<int>>'
                         // 'i'會被修改
    std::cout << i << std::endl;  // 輸出1
}
這項功能將加入標頭檔<functional>之中，而非透過擴展語言來得到這項功能。
C++標準程式庫的變更 > 多态函数对象包装器

針對函数对象的多态包装器（又稱多态函数对象包装器）在語義和語法上和函式指標相似，但不像函式指標那麼狹隘。只要能被呼叫，且其參數能與包裝器相容的都能以多态函数对象包装器稱之（函式指標，成員函式指標或仿函式）。
透過以下例子，我們可以了解多态函数对象包装器的特性：
std::function<int (int, int)> func;  // 利用樣板類'function'
                                     // 建立包裝器
std::plus<int> add;  // 'plus'被宣告為'template<class T> T plus( T, T ) ;'
                     //  因此'add'的型別是'int add( int x, int y )'
func = &add;  // 可行。'add'的型參和回返值型別與'func'相符
 
int a = func (1, 2);  // 注意：若包裝器'func'沒有參考到任何函式
                      // 會丟出'std::bad_function_call'例外

std::function<bool (short, short)> func2 ;
if(!func2) { // 因為尚未賦值與'func2'任何函式，此條件式為真

    bool adjacent(long x, long y);
    func2 = &adjacent ;  // 可行。'adjacent'的型參和回返值型別可透過型別轉換進而與'func2'相符
  
    struct Test {
        bool operator()(short x, short y);
    };
    Test car;
    func = std::ref(car);  // 樣板類'std::ref'回傳一個struct 'car'
                           // 其成員函式'operator()'的包裝
}
func = func2;  // 可行。'func2'的型參和回返值型別可透過型別轉換進而與'func'相符
模板類function將定義在標頭檔<functional>，而不須更動到語言本身。
C++標準程式庫的變更 > 用於元編程的型別屬性

對於那些能自行創建或修改本身或其它程式的程式，我們稱之為元編程。這種行為可以發生在編譯或執行期。C++標準委員會已經決定引進一組由模板實現的函式庫，程式員可利用此一函式庫於編譯期進行元編程。
底下是一個以元編程來計算指數的例子：
template<int B, int N>
struct Pow {
    // recursive call and recombination.
    enum{ value = B*Pow<B, N-1>::value };
};

template< int B > 
struct Pow<B, 0> { 
    // ''N == 0'' condition of termination.
    enum{ value = 1 };
};
int quartic_of_three = Pow<3, 4>::value;
許多演算法能作用在不同的資料型別；C++模板支援泛型，這使得代碼能更緊湊和有用。然而，演算法經常會需要目前作用的資料型別的資訊。這種資訊可以透過型別屬性（type traits）於模板實體化時將該資訊萃取出來。
型別屬性能識別一個物件的種類和有關一個型別（class或struct）的特徵。標頭檔<type_traits>描述了我們能識別那些特徵。
底下的例子說明了模板函式‘elaborate’是如何根據給定的資料型別，從而實體化某一特定的演算法（algorithm.do_it）。
// 演算法一
template< bool B > struct Algorithm {
    template<class T1, class T2> static int do_it (T1 &, T2 &)  { /*...*/ }
};

// 演算法二
template<> struct Algorithm<true> {
    template<class T1, class T2> static int do_it (T1, T2)  { /*...*/ }
};

// 根據給定的型別，實體化之後的'elaborate'會選擇演算法一或二
template<class T1, class T2> 
int elaborate (T1 A, T2 B) 
{
    // 若T1為int且T2為float，選用演算法二
    // 其它情況選用演算法一
    return Algorithm<std::is_integral<T1>::value && std::is_floating_point<T2>::value>::do_it( A, B ) ;
}
此種編程技巧能寫出優美、簡潔的代碼；然而除錯是此種編程技巧的弱處：編譯期的錯誤訊息讓人不知所云，執行期的除錯更是困難。
C++標準程式庫的變更 > 用于计算函数对象返回类型的统一方法

要在編譯期決定一個樣板仿函式的回返值型別並不容易，特別是當回返值依賴於函式的參數時。舉例來說：
struct Clear {
    int    operator()(int);     // 參數與回返值的型別相同
    double operator()(double);  // 參數與回返值的型別相同
};

template <class Obj> 
class Calculus {
public:
    template<class Arg> Arg operator()(Arg& a) const
    {
        return member(a);
    }
private:
    Obj member;
};
實體化樣板類Calculus<Clear>，Calculus的仿函式其回返值總是和Clear的仿函式其回返值具有相同的型別。然而，若給定類別Confused:
struct Confused {
    double operator()(int);     // 參數與回返值的型別不相同
    int    operator()(double);  // 參數與回返值的型別不相同
};
企圖實體化樣板類Calculus<Confused>將導致Calculus的仿函式其回返值和類別Confused的仿函式其回返值有不同的型別。對於int和double之間的轉換，編譯器將給出警告。
模板std::result_of被TR1引進且被C++11所採納，可允許我們決定和使用一個仿函式其回返值的型別。底下，CalculusVer2物件使用std::result_of物件來推導其仿函式的回返值型別：
template< class Obj >
class CalculusVer2 {
public:
    template<class Arg>
    typename std::result_of<Obj(Arg)>::type operator()(Arg& a) const
    { 
        return member(a);
    }
private:
    Obj member;
};
如此一來，在實體化CalculusVer2<Confused>其仿函式時，不會有型別轉換，警告或是錯誤發生。
模板std::result_of在TR1和C++11有一點不同。TR1的版本允許實作在特殊情況下，可以無法決定一個函式呼叫其回返值型別。然而，因為C++11支持了decltype，實作被要求在所有情況下，皆能計算出回返值型別。
C++標準程式庫的變更 > iota 函数

条目：iota函数
iota 函数可将给定区间的值设定为从某值开始的连续值，例如将连续十个整数设定为从 1 开始的连续整数（即 1、2、3、4、5、6、7、8、9、10）。
#include <iostream>
#include <array>
#include <numeric>

std::array<int, 10> ai;
std::iota(ai.begin(), ai.end(), 1);
for(int i: ai){
  std::cout<<i<<" ";//1 2 3 4 5 6 7 8 9 10 
}
已被移除或是不包含在C++11標準的特性

預計由Technical Report提供支援：
模組（页面存档备份，存于）
十進制型別
数学专用函数
延後討論：
Concepts（概念 (C++)）
更完整或必備的垃圾回收支援
Reflection
Macro Scopes
被移除或廢棄的特性

循序點（sequence point），這個術語正被更為易懂的描述所取代。一個運算可以發生（is sequenced before）在另一個運算之前;又或者兩個運算彼此之間沒有順序關係（are unsequenced）。
export
exception specifications
std::auto_ptr（英语：）被std::unique_ptr取代。
仿函式基底類別 (std::unary_function, std::binary_function)、函式指針適配器、類別成員指針適配器以及綁定器 (binder)。
编译器实现

C++编译器对C++11新特性的支持情况：
Visual C++ 2010：C++0x Core Language Features In VC10: The Table（页面存档备份，存于）
Visual C++ 2010与Visual C++ 2012支持的C++11特性的对比列表：C++11 Features (Modern C++)（页面存档备份，存于）
Visual C++ 2013支持的C++11特性的对比列表：C++11 Features (Modern C++)（页面存档备份，存于）
Visual C++ 2015预览版支持的C++11/14/17特性的对比列表：VC2015 Preview语言特性列表 （页面存档备份，存于）
GCC 4.8.1已实现C++11标准的所有主要语言特性：Status of Experimental C++11 Support in GCC 4.8（页面存档备份，存于）
關聯項目

C++ Technical Report 1
C11
C++17
Constexpr，用於編譯時的常量與常量函數。
參考資料

↑   (PDF).   [2012-07-12]. （原始内容存档 (PDF)于2012-08-13）.
↑   (PDF).   [2009-02-06]. （原始内容存档 (PDF)于2008-12-21）.
參考資料 > 文章

a b  The C++ Source Bjarne Stroustrup（2006年1月2日）A Brief Look at C++0x
^  C/C++ Users Journal Bjarne Stroustrup (May, 2005) The Design of C++0x: Reinforcing C++’s proven strengths, while moving into the future
Web Log di Raffaele Rialdi（2005年9月16日）Il futuro di C++ raccontato da Herb Sutter
Informit.com（2006年8月5日）The Explicit Conversion Operators Proposal
Informit.com（2006年7月25日）Introducing the Lambda Library
Dr. Dobb's Portal Pete Becker（2006年4月11日）Regular Expressions TR1's regex implementation
Informit.com（2006年7月25日）The Type Traits Library
Dr. Dobb's Portal Pete Becker（2005年5月11日）C++ Function Objects in TR1
The C++ Source Howard E. Hinnant, Bjarne Stroustrup, and Bronek Kozicki（2008年3月10日）A Brief Introduction to Rvalue References（页面存档备份，存于）
DevX.com Special Report（2008年8月18日）C++0x: The Dawning of a New Standard（页面存档备份，存于）
外部連結

The C++ Standards Committee（页面存档备份，存于）
Bjarne Stroustrup's homepage（页面存档备份，存于）
C++0X: The New Face of Standard C++
Herb Sutter's blog coverage of C++0X（页面存档备份，存于）
A talk on C++0x given by Bjarne Stroustrup at the University of Waterloo（页面存档备份，存于）
A quick and dirty introduction to C++0x (as of November 2007)（页面存档备份，存于）
The State of the Language: An Interview with Bjarne Stroustrup (August 15, 2008)（页面存档备份，存于）
Working draft for the C++ language, October 4, 2008（页面存档备份，存于）
李湛 (趙國公)

李湛（7世纪—710年代），字興宗，唐朝瀛州饒陽縣（今河北饒陽）人，李義府之子，曾參與神龍革命，推翻武則天，迎立唐中宗，後封趙國公。
簡介

年方六歲，以父親的關係，授周王府文學官。乾封元年（666年），父亲李义府死于流放的巂州。上元元年（674年），大赦，李义府的妻儿才得以回到洛阳，李湛是否在其中不详。武周如意元年（692年），已经称帝的武则天以李义府等六人曾经拥立她为皇后，追赠六人官职。长安元年（701年），左千牛卫将军李湛又因李义府之子的身份获赐实封三百户。神龍（705年—707年）初年，累遷散騎常侍，封河間郡公。
宰相張柬之打算發動兵變，殺張易之，以李湛為左羽林將軍。李湛曾與敬仲曄兩人，向唐中宗陳述兵變的必要，中宗同意了。神龍革命時，唐中宗反悔，李湛強迫中宗入宮。
在宮中，武則天對李湛說：「你也是政變中的將領麼？我對你跟你父親都不薄，你怎麼會造反？」唐中宗復辟後，封李湛為右羽林大將軍、趙國公，加实封通前满五百户。复授左散骑常侍，武三思讨厌他，贬为果州刺史，历任洺州刺史、绛州刺史，累转為左領軍衛大將軍。開元初卒，赠幽州都督。
參考資料

《舊唐書》·卷82·列傳第三十二
李荣 (哲学家)

李荣（？—？），中国唐朝哲学家，东明观道士。他汇编了一套对道教书籍《道德经》的评注。他的评注被称为《老子李荣注》。
《全唐诗》卷八百六十九录李荣《咏兴善寺佛殿灾》并注：“荣，巴西人”。《全唐诗》卷八百八十二亦载薛曜诗《登绵州富乐山别李道士荣》。李荣好友卢照邻亦曾作《代女道士王灵妃赠道士李荣诗》。
杜光庭《广圣义》：“任真子李荣注《道德经》上下两卷。”“唐朝士成玄英、蔡子晃、黄玄颐、李荣、车惠弼，皆明重玄之道。”可见李荣有号任真子。
当时，僧道两教互相排斥。唐高宗总章年间，兴善寺遭火灾，李荣作诗：“道善何曾善，云兴遂不兴。如来烧亦尽，唯有一群僧。”虽然当时的人欣赏李荣的诗，但李荣的声誉也因幸灾乐祸而受损。
唐高宗末年，李荣居住于东明观，常与太学博士罗道琮、太学助教康国安等论道。
由《王右丞集》卷二十五《大荐福寺大德道光禅师塔铭》，可见李荣有一兄子道光禅师。
注释及参考文献

↑  《大唐新语》卷一十二：京城流俗，僧、道常争二教优劣，递相排斥。总章中兴善寺为火灾所焚，尊像荡尽。东明观道士李荣因泳之曰：“道善何曾善，云兴遂不兴。如来烧亦尽，唯有一群僧”。时人虽赏荣诗，然声称从此而减。
↑  《旧唐书·罗道琮传》：高宗末，官至太学博士。每与太学助教康国安、道士李荣等讲论，为时所称。
李·卡特摩尔

| 0 | 1 | 2 | 3 |
| --- | --- | --- | --- |
 
個人
全名:  Lee Barry Cattermole
出生日期:   (1988-03-21) 1988年3月21日（36歲）
出生地點:  英格蘭蒂斯河畔斯托克頓
身高:  5英尺10英寸（1.78）
位置:  防守中場
青年隊
1998−2005:  米杜士堡
職業*
| 年份 |  球隊 |   |  （） |
| 2005−2008 |  米杜士堡 |  69 |  (3) |
| 2008−2009 |  韋根 |  33 |  (1) |
| 2009−2019 |  新特蘭 |  233 |  (10) |
| 2019−2020 |  VVV-芬洛 |  11 |  (0) |
‡
| 2003 |  英格蘭 U16 |  1 |  (0) |
| 2004 |  英格蘭 U17 |  4 |  (0) |
| 2005 |  英格蘭 U18 |  1 |  (0) |
| 2006 |  英格蘭 U19 |  1 |  (0) |
| 2007−2010 |  英格蘭 U21 |  16 |  (3) |
 * 職業次數與數僅計算國內聯賽部份 最後更新於：2020年8月14日 (五) 16:38 (UTC) ‡ 次數和數 最後更新於：2013年6月7日 (五) 05:59 (UTC)
李·巴里·卡特摩尔（英語：，1988年3月21日—）出生於英格蘭蒂斯塞德（Teesside）的蒂斯河畔斯托克（Stockton-on-Tees），是一名足球運動員，司職中場，現時已退役。