C++11

喜欢ヅ旅行 2022-02-24 15:44 200阅读 0赞

# 1.  Wiki C++11 介绍 #

转自 [https://zh.wikipedia.org/wiki/C%2B%2B11][https_zh.wikipedia.org_wiki_C_2B_2B11]

**C++11**，先前被称作**C++0x**，即ISO/IEC 14882:2011，是目前的[C++编程语言][C]的正式标准。它取代第二版标准ISO/IEC 14882:2003(第一版ISO/IEC 14882:1998公开于1998年，第二版于2003年更新，分别通称C++98以及C++03，两者差异很小)。新的标准包含[核心语言][Link 1]的新机能，而且扩展[C++标准程序库][C 1]，并入了大部分的[C++ Technical Report 1][C_ Technical Report 1]程序库(数学的特殊函数除外)。最新的消息被公开在 [ISO C++ 委员会网站(英文)][ISO C_]。

[ISO][]／[IEC][] JTC1/SC22/WG21 C++ 标准委员会计划在2010年8月之前完成对最终委员会草案的投票，以及于2011年3月召开的标准会议完成国际标准的最终草案。然而，WG21预期ISO将要花费六个月到一年的时间才能正式发布新的 C++ 标准。为了能够如期完成，委员会决定致力于直至2006年为止的提案，忽略新的提案[\[1\]][1]。最终于2011年8月12日公布，并于2011年9月出版。

2012年2月28日的国际标准草案([N3376][])是最接近于现行标准的草案，差异仅有编辑上的修正。

像C++这样的[编程语言][Link 2]，通过一种演化的的过程来发展其定义。这个过程不可避免地将引发与现有代码的兼容问题，在C++的发展过程中偶尔会发生。不过根据[Bjarne Stroustrup][](C++的创始人并且是委员会的一员)表示，新的标准将几乎100%兼容于现有标准。

<table style="border-style:solid; border-color:rgb(170,170,170); font-size:14px; background-color:rgb(249,249,249); padding:5px; color:rgb(0,0,0); font-family:sans-serif; line-height:22.0781px"> 
 <tbody> 
  <tr> 
   <td> 
    <div style="direction:ltr; text-align:center"> 
     <h2 style="margin:0px 0px 0.6em; overflow:hidden; padding:0px; border:none; font-size:14px; display:inline"> 目录</h2> &nbsp; 
     <span>&nbsp;[<a href="https://zh.wikipedia.org/wiki/C%2B%2B11#" style="text-decoration:none; color:rgb(11,0,128)" rel="nofollow">隐藏</a>]&nbsp;</span> 
    </div> 
    <ul style="line-height:1.5em; list-style-type:none; margin:0.3em 0px; padding:0px"> 
     <li style="margin-bottom:0.1em"><a href="https://zh.wikipedia.org/wiki/C%2B%2B11#.E5.80.99.E9.81.B8.E8.AE.8A.E6.9B.B4" style="text-decoration:none; color:rgb(11,0,128)" rel="nofollow"><span>1</span>&nbsp;<span>候选变更</span></a></li> 
     <li style="margin-bottom:0.1em"><a href="https://zh.wikipedia.org/wiki/C%2B%2B11#C.2B.2B.E6.A0.B8.E5.BF.83.E8.AA.9E.E8.A8.80.E7.9A.84.E6.93.B4.E5.85.85" style="text-decoration:none; color:rgb(11,0,128)" rel="nofollow"><span>2</span>&nbsp;<span>C++核心语言的扩充</span></a></li> 
     <li style="margin-bottom:0.1em"><a href="https://zh.wikipedia.org/wiki/C%2B%2B11#.E6.A0.B8.E5.BF.83.E8.AA.9E.E8.A8.80.E7.9A.84.E5.9F.B7.E8.A1.8C.E6.9C.9F.E8.A1.A8.E7.8F.BE.E5.BC.B7.E5.8C.96" style="text-decoration:none; color:rgb(11,0,128)" rel="nofollow"><span>3</span>&nbsp;<span>核心语言的运行期表现强化</span></a> 
      <ul style="line-height:1.5em; list-style-type:none; margin:0px 0px 0px 2em; padding:0px"> 
       <li style="margin-bottom:0.1em"><a href="https://zh.wikipedia.org/wiki/C%2B%2B11#.E5.8F.B3.E5.80.BC.E5.BC.95.E7.94.A8.E5.92.8C_move_.E8.AA.9E.E6.84.8F" style="text-decoration:none; color:rgb(11,0,128)" rel="nofollow"><span>3.1</span>&nbsp;<span>右值引用和 move 语义</span></a></li> 
       <li style="margin-bottom:0.1em"><a href="https://zh.wikipedia.org/wiki/C%2B%2B11#.E6.B3.9B.E5.8C.96.E7.9A.84.E5.B8.B8.E6.95.B8.E8.A1.A8.E7.A4.BA.E5.BC.8F" style="text-decoration:none; color:rgb(11,0,128)" rel="nofollow"><span>3.2</span>&nbsp;<span>泛化的常数表示式</span></a></li> 
       <li style="margin-bottom:0.1em"><a href="https://zh.wikipedia.org/wiki/C%2B%2B11#.E5.B0.8DPOD.E5.AE.9A.E7.BE.A9.E7.9A.84.E4.BF.AE.E6.AD.A3" style="text-decoration:none; color:rgb(11,0,128)" rel="nofollow"><span>3.3</span>&nbsp;<span>对POD定义的修正</span></a></li> 
      </ul> </li> 
     <li style="margin-bottom:0.1em"><a href="https://zh.wikipedia.org/wiki/C%2B%2B11#.E6.A0.B8.E5.BF.83.E8.AA.9E.E8.A8.80.E5.BB.BA.E6.A7.8B.E6.9C.9F.E8.A1.A8.E7.8F.BE.E7.9A.84.E5.8A.A0.E5.BC.B7" style="text-decoration:none; color:rgb(11,0,128)" rel="nofollow"><span>4</span>&nbsp;<span>核心语言建构期表现的加强</span></a> 
      <ul style="line-height:1.5em; list-style-type:none; margin:0px 0px 0px 2em; padding:0px"> 
       <li style="margin-bottom:0.1em"><a href="https://zh.wikipedia.org/wiki/C%2B%2B11#.E5.A4.96.E9.83.A8.E6.A8.A1.E6.9D.BF" style="text-decoration:none; color:rgb(11,0,128)" rel="nofollow"><span>4.1</span>&nbsp;<span>外部模板</span></a></li> 
      </ul> </li> 
     <li style="margin-bottom:0.1em"><a href="https://zh.wikipedia.org/wiki/C%2B%2B11#.E6.A0.B8.E5.BF.83.E8.AA.9E.E8.A8.80.E4.BD.BF.E7.94.A8.E6.80.A7.E7.9A.84.E5.8A.A0.E5.BC.B7" style="text-decoration:none; color:rgb(11,0,128)" rel="nofollow"><span>5</span>&nbsp;<span>核心语言使用性的加强</span></a> 
      <ul style="line-height:1.5em; list-style-type:none; margin:0px 0px 0px 2em; padding:0px"> 
       <li style="margin-bottom:0.1em"><a href="https://zh.wikipedia.org/wiki/C%2B%2B11#.E5.88.9D.E5.A7.8B.E5.8C.96.E5.88.97.E8.A1.A8" style="text-decoration:none; color:rgb(11,0,128)" rel="nofollow"><span>5.1</span>&nbsp;<span>初始化列表</span></a></li> 
       <li style="margin-bottom:0.1em"><a href="https://zh.wikipedia.org/wiki/C%2B%2B11#.E7.B5.B1.E4.B8.80.E7.9A.84.E5.88.9D.E5.A7.8B.E5.8C.96" style="text-decoration:none; color:rgb(11,0,128)" rel="nofollow"><span>5.2</span>&nbsp;<span>统一的初始化</span></a></li> 
       <li style="margin-bottom:0.1em"><a href="https://zh.wikipedia.org/wiki/C%2B%2B11#.E5.9E.8B.E5.88.A5.E6.8E.A8.E5.B0.8E" style="text-decoration:none; color:rgb(11,0,128)" rel="nofollow"><span>5.3</span>&nbsp;<span>类型推导</span></a></li> 
       <li style="margin-bottom:0.1em"><a href="https://zh.wikipedia.org/wiki/C%2B%2B11#.E4.BB.A5.E7.AF.84.E5.9C.8D.E7.82.BA.E5.9F.BA.E7.A4.8E.E7.9A.84_for_.E8.BF.B4.E5.9C.88" style="text-decoration:none; color:rgb(11,0,128)" rel="nofollow"><span>5.4</span>&nbsp;<span>以范围为基础的 for 循环</span></a></li> 
       <li style="margin-bottom:0.1em"><a href="https://zh.wikipedia.org/wiki/C%2B%2B11#Lambda.E5.87.BD.E5.BC.8F.E8.88.87.E8.A1.A8.E7.A4.BA.E5.BC.8F" style="text-decoration:none; color:rgb(11,0,128)" rel="nofollow"><span>5.5</span>&nbsp;<span>Lambda函数与表示式</span></a></li> 
       <li style="margin-bottom:0.1em"><a href="https://zh.wikipedia.org/wiki/C%2B%2B11#.E5.8F.A6.E4.B8.80.E7.A8.AE.E7.9A.84.E5.87.BD.E5.BC.8F.E8.AA.9E.E6.B3.95" style="text-decoration:none; color:rgb(11,0,128)" rel="nofollow"><span>5.6</span>&nbsp;<span>另一种的函数语法</span></a></li> 
       <li style="margin-bottom:0.1em"><a href="https://zh.wikipedia.org/wiki/C%2B%2B11#.E7.89.A9.E4.BB.B6.E5.BB.BA.E6.A7.8B.E7.9A.84.E6.94.B9.E8.89.AF" style="text-decoration:none; color:rgb(11,0,128)" rel="nofollow"><span>5.7</span>&nbsp;<span>对象建构的改良</span></a></li> 
       <li style="margin-bottom:0.1em"><a href="https://zh.wikipedia.org/wiki/C%2B%2B11#.E9.A1.AF.E5.BC.8F.E8.99.9B.E5.87.BD.E6.95.B8.E9.87.8D.E8.BC.89" style="text-decoration:none; color:rgb(11,0,128)" rel="nofollow"><span>5.8</span>&nbsp;<span>显式虚函数重载</span></a></li> 
       <li style="margin-bottom:0.1em"><a href="https://zh.wikipedia.org/wiki/C%2B%2B11#.E7.A9.BA.E6.8C.87.E6.A8.99" style="text-decoration:none; color:rgb(11,0,128)" rel="nofollow"><span>5.9</span>&nbsp;<span>空指针</span></a></li> 
       <li style="margin-bottom:0.1em"><a href="https://zh.wikipedia.org/wiki/C%2B%2B11#.E5.BC.B7.E5.9E.8B.E5.88.A5.E5.88.97.E8.88.89" style="text-decoration:none; color:rgb(11,0,128)" rel="nofollow"><span>5.10</span>&nbsp;<span>强类型枚举</span></a></li> 
       <li style="margin-bottom:0.1em"><a href="https://zh.wikipedia.org/wiki/C%2B%2B11#.E8.A7.92.E6.8B.AC.E8.99.9F" style="text-decoration:none; color:rgb(11,0,128)" rel="nofollow"><span>5.11</span>&nbsp;<span>角括号</span></a></li> 
       <li style="margin-bottom:0.1em"><a href="https://zh.wikipedia.org/wiki/C%2B%2B11#.E9.A1.AF.E5.BC.8F.E5.9E.8B.E5.88.A5.E8.BD.89.E6.8F.9B.E5.AD.90" style="text-decoration:none; color:rgb(11,0,128)" rel="nofollow"><span>5.12</span>&nbsp;<span>显式类型转换子</span></a></li> 
       <li style="margin-bottom:0.1em"><a href="https://zh.wikipedia.org/wiki/C%2B%2B11#.E6.A8.A1.E6.9D.BF.E7.9A.84.E5.88.A5.E5.90.8D" style="text-decoration:none; color:rgb(11,0,128)" rel="nofollow"><span>5.13</span>&nbsp;<span>模板的别名</span></a></li> 
       <li style="margin-bottom:0.1em"><a href="https://zh.wikipedia.org/wiki/C%2B%2B11#.E7.84.A1.E9.99.90.E5.88.B6.E7.9A.84unions" style="text-decoration:none; color:rgb(11,0,128)" rel="nofollow"><span>5.14</span>&nbsp;<span>无限制的unions</span></a></li> 
      </ul> </li> 
     <li style="margin-bottom:0.1em"><a href="https://zh.wikipedia.org/wiki/C%2B%2B11#.E6.A0.B8.E5.BF.83.E8.AA.9E.E8.A8.80.E8.83.BD.E5.8A.9B.E7.9A.84.E6.8F.90.E5.8D.87" style="text-decoration:none; color:rgb(11,0,128)" rel="nofollow"><span>6</span>&nbsp;<span>核心语言能力的提升</span></a> 
      <ul style="line-height:1.5em; list-style-type:none; margin:0px 0px 0px 2em; padding:0px"> 
       <li style="margin-bottom:0.1em"><a href="https://zh.wikipedia.org/wiki/C%2B%2B11#-.7BA.7Czh-hans:.E5.8F.98.E9.95.BF.E5.8F.82.E6.95.B0.E6.A8.A1.E6.9D.BF.3B_zh-hant:.E4.B8.8D.E5.AE.9A.E9.95.B7.E5.8F.83.E6.95.B8.E6.A8.A1.E6.9D.BF.7D-" style="text-decoration:none; color:rgb(11,0,128)" rel="nofollow"><span>6.1</span>&nbsp;<span>变长参数模板</span></a></li> 
       <li style="margin-bottom:0.1em"><a href="https://zh.wikipedia.org/wiki/C%2B%2B11#.E6.96.B0.E7.9A.84.E5.AD.97.E4.B8.B2.E5.AD.97.E9.9D.A2.E5.80.BC" style="text-decoration:none; color:rgb(11,0,128)" rel="nofollow"><span>6.2</span>&nbsp;<span>新的字符串字面值</span></a></li> 
       <li style="margin-bottom:0.1em"><a href="https://zh.wikipedia.org/wiki/C%2B%2B11#.E4.BD.BF.E7.94.A8.E8.80.85.E8.87.AA.E8.A8.82.E7.9A.84.E5.AD.97.E9.9D.A2.E5.80.BC" style="text-decoration:none; color:rgb(11,0,128)" rel="nofollow"><span>6.3</span>&nbsp;<span>用户自定义的字面值</span></a></li> 
       <li style="margin-bottom:0.1em"><a href="https://zh.wikipedia.org/wiki/C%2B%2B11#.E5.A4.9A.E5.B7.A5.E8.A8.98.E6.86.B6.E9.AB.94.E6.A8.A1.E5.9E.8B" style="text-decoration:none; color:rgb(11,0,128)" rel="nofollow"><span>6.4</span>&nbsp;<span>多任务内存模型</span></a></li> 
       <li style="margin-bottom:0.1em"><a href="https://zh.wikipedia.org/wiki/C%2B%2B11#thread-local.E7.9A.84.E5.AD.98.E5.84.B2.E6.9C.9F.E9.99.90" style="text-decoration:none; color:rgb(11,0,128)" rel="nofollow"><span>6.5</span>&nbsp;<span>thread-local的存储期限</span></a></li> 
       <li style="margin-bottom:0.1em"><a href="https://zh.wikipedia.org/wiki/C%2B%2B11#.E4.BD.BF.E7.94.A8.E6.88.96.E7.A6.81.E7.94.A8.E7.89.A9.E4.BB.B6.E7.9A.84.E9.A0.90.E8.A8.AD.E5.87.BD.E5.BC.8F" style="text-decoration:none; color:rgb(11,0,128)" rel="nofollow"><span>6.6</span>&nbsp;<span>使用或禁用对象的默认函数</span></a></li> 
       <li style="margin-bottom:0.1em"><a href="https://zh.wikipedia.org/wiki/C%2B%2B11#long_long_int.E5.9E.8B.E5.88.A5" style="text-decoration:none; color:rgb(11,0,128)" rel="nofollow"><span>6.7</span>&nbsp;<span>long long int类型</span></a></li> 
       <li style="margin-bottom:0.1em"><a href="https://zh.wikipedia.org/wiki/C%2B%2B11#.E9.9D.9C.E6.85.8Bassertion" style="text-decoration:none; color:rgb(11,0,128)" rel="nofollow"><span>6.8</span>&nbsp;<span>静态assertion</span></a></li> 
       <li style="margin-bottom:0.1em"><a href="https://zh.wikipedia.org/wiki/C%2B%2B11#.E5.85.81.E8.A8.B1sizeof.E9.81.8B.E7.AE.97.E5.AD.90.E4.BD.9C.E7.94.A8.E5.9C.A8.E9.A1.9E.E5.88.A5.E7.9A.84.E8.B3.87.E6.96.99.E6.88.90.E5.93.A1.E4.B8.8A.EF.BC.8C.E7.84.A1.E9.A0.88.E6.98.8E.E7.A2.BA.E7.9A.84.E7.89.A9.E4.BB.B6" style="text-decoration:none; color:rgb(11,0,128)" rel="nofollow"><span>6.9</span>&nbsp;<span>允许sizeof运算符作用在类型的数据成员上，无须明确的对象</span></a></li> 
       <li style="margin-bottom:0.1em"><a href="https://zh.wikipedia.org/wiki/C%2B%2B11#.E5.9E.83.E5.9C.BE.E5.9B.9E.E6.94.B6.E6.A9.9F.E5.88.B6" style="text-decoration:none; color:rgb(11,0,128)" rel="nofollow"><span>6.10</span>&nbsp;<span>垃圾回收机制</span></a></li> 
      </ul> </li> 
     <li style="margin-bottom:0.1em"><a href="https://zh.wikipedia.org/wiki/C%2B%2B11#C.2B.2B.E6.A8.99.E6.BA.96.E7.A8.8B.E5.BC.8F.E5.BA.AB.E7.9A.84.E8.AE.8A.E6.9B.B4" style="text-decoration:none; color:rgb(11,0,128)" rel="nofollow"><span>7</span>&nbsp;<span>C++标准程序库的变更</span></a> 
      <ul style="line-height:1.5em; list-style-type:none; margin:0px 0px 0px 2em; padding:0px"> 
       <li style="margin-bottom:0.1em"><a href="https://zh.wikipedia.org/wiki/C%2B%2B11#.E6.A8.99.E6.BA.96.E5.BA.AB.E5.85.83.E4.BB.B6.E4.B8.8A.E7.9A.84.E5.8D.87.E7.B4.9A" style="text-decoration:none; color:rgb(11,0,128)" rel="nofollow"><span>7.1</span>&nbsp;<span>标准库组件上的升级</span></a></li> 
       <li style="margin-bottom:0.1em"><a href="https://zh.wikipedia.org/wiki/C%2B%2B11#.E5.9F.B7.E8.A1.8C.E7.B7.92.E6.94.AF.E6.8F.B4" style="text-decoration:none; color:rgb(11,0,128)" rel="nofollow"><span>7.2</span>&nbsp;<span>线程支持</span></a></li> 
       <li style="margin-bottom:0.1em"><a href="https://zh.wikipedia.org/wiki/C%2B%2B11#.E5.A4.9A.E5.85.83.E7.B5.84.E5.9E.8B.E5.88.A5" style="text-decoration:none; color:rgb(11,0,128)" rel="nofollow"><span>7.3</span>&nbsp;<span>多元组类型</span></a></li> 
       <li style="margin-bottom:0.1em"><a href="https://zh.wikipedia.org/wiki/C%2B%2B11#.E9.9B.9C.E6.B9.8A.E8.A1.A8" style="text-decoration:none; color:rgb(11,0,128)" rel="nofollow"><span>7.4</span>&nbsp;<span>散列表</span></a></li> 
       <li style="margin-bottom:0.1em"><a href="https://zh.wikipedia.org/wiki/C%2B%2B11#.E6.AD.A3.E8.A6.8F.E8.A1.A8.E7.A4.BA.E5.BC.8F" style="text-decoration:none; color:rgb(11,0,128)" rel="nofollow"><span>7.5</span>&nbsp;<span>正则表达式</span></a></li> 
       <li style="margin-bottom:0.1em"><a href="https://zh.wikipedia.org/wiki/C%2B%2B11#.E9.80.9A.E7.94.A8.E6.99.BA.E8.83.BD.E6.8C.87.E9.87.9D" style="text-decoration:none; color:rgb(11,0,128)" rel="nofollow"><span>7.6</span>&nbsp;<span>通用智能指针</span></a></li> 
       <li style="margin-bottom:0.1em"><a href="https://zh.wikipedia.org/wiki/C%2B%2B11#.E5.8F.AF.E6.89.A9.E5.B1.95.E7.9A.84.E9.9A.8F.E6.9C.BA.E6.95.B0.E5.8A.9F.E8.83.BD" style="text-decoration:none; color:rgb(11,0,128)" rel="nofollow"><span>7.7</span>&nbsp;<span>可扩展的随机数功能</span></a></li> 
       <li style="margin-bottom:0.1em"><a href="https://zh.wikipedia.org/wiki/C%2B%2B11#.E5.8C.85.E8.A3.85.E5.BC.95.E7.94.A8" style="text-decoration:none; color:rgb(11,0,128)" rel="nofollow"><span>7.8</span>&nbsp;<span>包装引用</span></a></li> 
       <li style="margin-bottom:0.1em"><a href="https://zh.wikipedia.org/wiki/C%2B%2B11#.E5.A4.9A.E6.80.81.E5.87.BD.E6.95.B0.E5.AF.B9.E8.B1.A1.E5.8C.85.E8.A3.85.E5.99.A8" style="text-decoration:none; color:rgb(11,0,128)" rel="nofollow"><span>7.9</span>&nbsp;<span>多态函数对象包装器</span></a></li> 
       <li style="margin-bottom:0.1em"><a href="https://zh.wikipedia.org/wiki/C%2B%2B11#.E7.94.A8.E6.96.BC.E5.85.83.E7.B7.A8.E7.A8.8B.E7.9A.84.E5.9E.8B.E5.88.A5.E5.B1.AC.E6.80.A7" style="text-decoration:none; color:rgb(11,0,128)" rel="nofollow"><span>7.10</span>&nbsp;<span>用于元编程的类型属性</span></a></li> 
       <li style="margin-bottom:0.1em"><a href="https://zh.wikipedia.org/wiki/C%2B%2B11#.E7.94.A8.E4.BA.8E.E8.AE.A1.E7.AE.97.E5.87.BD.E6.95.B0.E5.AF.B9.E8.B1.A1.E8.BF.94.E5.9B.9E.E7.B1.BB.E5.9E.8B.E7.9A.84.E7.BB.9F.E4.B8.80.E6.96.B9.E6.B3.95" style="text-decoration:none; color:rgb(11,0,128)" rel="nofollow"><span>7.11</span>&nbsp;<span>用于计算函数对象返回类型的统一方法</span></a></li> 
      </ul> </li> 
     <li style="margin-bottom:0.1em"><a href="https://zh.wikipedia.org/wiki/C%2B%2B11#.E5.B7.B2.E8.A2.AB.E7.A7.BB.E9.99.A4.E6.88.96.E6.98.AF.E4.B8.8D.E5.8C.85.E5.90.AB.E5.9C.A8_C.2B.2B11_.E6.A8.99.E6.BA.96.E7.9A.84.E7.89.B9.E8.89.B2" style="text-decoration:none; color:rgb(11,0,128)" rel="nofollow"><span>8</span>&nbsp;<span>已被移除或是不包含在 C++11 标准的特色</span></a></li> 
     <li style="margin-bottom:0.1em"><a href="https://zh.wikipedia.org/wiki/C%2B%2B11#.E8.A2.AB.E7.A7.BB.E9.99.A4.E6.88.96.E5.BB.A2.E6.A3.84.E7.9A.84.E7.89.B9.E8.89.B2" style="text-decoration:none; color:rgb(11,0,128)" rel="nofollow"><span>9</span>&nbsp;<span>被移除或废弃的特色</span></a></li> 
     <li style="margin-bottom:0.1em"><a href="https://zh.wikipedia.org/wiki/C%2B%2B11#.E7.BC.96.E8.AF.91.E5.99.A8.E5.AE.9E.E7.8E.B0" style="text-decoration:none; color:rgb(11,0,128)" rel="nofollow"><span>10</span>&nbsp;<span>编译器实现</span></a></li> 
     <li style="margin-bottom:0.1em"><a href="https://zh.wikipedia.org/wiki/C%2B%2B11#.E9.97.9C.E8.81.AF.E9.A0.85.E7.9B.AE" style="text-decoration:none; color:rgb(11,0,128)" rel="nofollow"><span>11</span>&nbsp;<span>关系项目</span></a></li> 
     <li style="margin-bottom:0.1em"><a href="https://zh.wikipedia.org/wiki/C%2B%2B11#.E5.8F.83.E8.80.83.E8.B3.87.E6.96.99" style="text-decoration:none; color:rgb(11,0,128)" rel="nofollow"><span>12</span>&nbsp;<span>参考资料</span></a> 
      <ul style="line-height:1.5em; list-style-type:none; margin:0px 0px 0px 2em; padding:0px"> 
       <li style="margin-bottom:0.1em"><a href="https://zh.wikipedia.org/wiki/C%2B%2B11#C.2B.2B.E6.A8.99.E6.BA.96.E5.A7.94.E5.93.A1.E6.9C.83.E6.96.87.E4.BB.B6" style="text-decoration:none; color:rgb(11,0,128)" rel="nofollow"><span>12.1</span>&nbsp;<span>C++标准委员会文件</span></a></li> 
       <li style="margin-bottom:0.1em"><a href="https://zh.wikipedia.org/wiki/C%2B%2B11#.E6.96.87.E7.AB.A0" style="text-decoration:none; color:rgb(11,0,128)" rel="nofollow"><span>12.2</span>&nbsp;<span>文章</span></a></li> 
      </ul> </li> 
     <li style="margin-bottom:0.1em"><a href="https://zh.wikipedia.org/wiki/C%2B%2B11#.E5.A4.96.E9.83.A8.E9.80.A3.E7.B5.90" style="text-decoration:none; color:rgb(11,0,128)" rel="nofollow"><span>13</span>&nbsp;<span>外部链接</span></a></li> 
    </ul> </td> 
  </tr> 
 </tbody> 
</table>

## \[\]候选变更 ##

C++的修订包含核心语言以及标准程序库。

在发展新标准的每个机能上，委员会采取了几个方向：

*  维持与C++98，可能的话还有[C][C 2]之间的稳定性与兼容性；
 *  尽可能不通过核心语言的扩展，而是通过标准程序库来引进新的特色；
 *  能够演进编程技术的变更优先；
 *  改进 C++ 以帮助系统以及库设计，而不是引进只针对特别应用的新特色；
 *  增进类型安全，提供对现行不安全的技术更安全的替代方案；
 *  增进直接对硬件工作的能力与表现；
 *  提供现实世界中问题的适当解决方案；
 *  实行“zero-overhead”原则(某些功能要求的额外支持只有在该功能被使用时才能使用);
 *  使C++易于教授与学习

对初学者的注重被认为是重要的，因为他们构成了计算机程序员的主体。也因为许多初学者不愿扩展他们对 C++ 的知识，只限于使用他们对 C++ 专精的部分。此外，考虑到 C++ 被广泛的使用(包含应用领域和编程风格)，即便是最有经验的程序员在面对新的编程范式时也会成为初学者。

## \[\]C++核心语言的扩充 ##

C++委员会的主要焦点是在语言核心的发展上。核心语言将被大幅改善的领域包括[多线程][Link 3](或称为“多线程”)支持、[泛型编程][Link 4]、统一的初始化，以及性能表现的加强。

在此分成4个区块来讨论核心语言的特色以及变更： 运行期表现强化、建构期表现强化、可用性强化，还有新的功能。某些特色可能会同时属于多个区块，但在此仅于其最具代表性的区块描述该特色。

## \[\]核心语言的运行期表现强化 ##

以下的语言机能主要用来提升某些性能表现，像是内存或是速度上的表现。

### \[\]右值引用和 move 语义 ###

在 C++03及之前的标准，临时对象(称为右值"R-values"，位于赋值运算符之右)无法被改变，在 C 中亦同(且被视为无法和 **const T&** 做出区分)。尽管在某些情况下临时对象的确会被改变，甚至也被视为是一个有用的漏洞。

C++11 增加一个新的非常数引用(reference)类型，称作右值引用(R-value reference)，标记为T &&。右值引用所引用的临时对象可以在该临时对象被初始化之后做修改，这是为了允许 move 语义。

C++03 性能上被长期被诟病的其中之一，就是其耗时且不必要的深度拷贝。深度拷贝会发生在当对象是以传值的方式传递。举例而言，std::vector<T> 是内部保存了 C-style 数组的一个包装，如果一个std::vector<T>的临时对象被建构或是从函数返回，要将其存储只能通过生成新的std::vector<T>并且把该临时对象所有的数据复制进去。该临时对象和其拥有的內存会被摧毁。(为了讨论上的方便，这里忽略返回值优化)

在 C++11，一个std::vector的 "move 构造函数" 对某个vector的右值引用可以单纯地从右值复制其内部 C-style 数组的指针到新的 vector，然后留下空的右值。这个操作不需要数组的复制，而且空的临时对象的析构也不会摧毁内存。传回vector临时对象的函数不需要显式地传回std::vector<T>&&。如果vector没有 move 构造函数，那么复制构造函数将被调用，以const std::vector<T> &的正常形式。 如果它确实有 move 构造函数，那么就会调用 move 构造函数，这能够免除大幅的内存配置。

基于安全的理由，具名的参数将永远不被认定为右值，即使它是被如此声明的；为了获得右值必须使用 std::move<T>()。

bool is_r_value(int &&) {
          return true; }
    bool is_r_value(const int &) {
          return false; }
     
    void test(int && i)
    {
         
        is_r_value(i); // i 為具名變數，即使被宣告成右值也不會被認定是右值。
        is_r_value(std::move<int&>(i)); // 使用 std::move<T>() 取得右值。
    }

由于右值引用的用语特性以及对于左值引用(L-value references;regular references)的某些用语修正，右值引用允许开发者提供完美转发 (perfect function forwarding)。当与[变长参数模板][Link 5]结合，这项能力允许函数模板能够完美地转送引数给其他接受这些特定引数的函数。最大的用处在于转送构造函数参数，创造出能够自动为这些特定引数调用正确建构式的工厂函数(factory function)。

### \[\]泛化的常数表示式 ###

C++ 本来就已具备常数表示式(constant expression)的概念。像是 3+4 总是会产生相同的结果并且没有任何的副作用。常数表示式对编译器来说是优化的机会，编译器时常在编译期运行它们并且将值存入程序中。同样地，在许多场合下，C++ 规格要求使用常数表示式。例如在数组大小的定义上，以及枚举值(enumerator values)都要求必须是常数表示式。

然而，常数表示式总是在遇上了函数调用或是对象建构式时就终结。所以像是以下的例子是不合法的：

int GetFive() {
         return 5;}
     
    int some_value[GetFive() + 5]；// 欲產生 10 個整數的陣列。 不合法的 C++ 寫法

这不是合法的 C++，因为 GetFive() + 5 并不是常数表示式。编译器无从得知 GetFive 实际上在运行期是常数。理论上而言，这个函数可能会影响全局参数，或者调用其他的非运行期(non-runtime)常数函数等。

C++11引进关键字 constexpr 允许用户保证函数或是对象建构式是编译期常数。以上的例子可以被写成像是下面这样：

constexpr int GetFive() {
         return 5;}
     
    int some_value[GetFive() + 5]；// 欲產生 10 個整數的陣列。合法的C++11寫法

这使得编译器能够了解并去验证 GetFive 是个编译期常数。

对函数使用 constexpr 在函数可以做的事上面加上了非常严格的条件。首先，该函数的回返值类型不能为 void。第二点，函数的内容必须依照 "return*expr*" 的形式。第三点，在引数取代后，expr 必须是个常数表示式。这些常数表示式只能够调用其他被定义为 constexpr 的函数，或是其他常数表示式的数据参数。 最后一点，有着这样标签的函数直到在该编译单元内被定义之前是不能够被调用的。

参数也可以被定义为常数表示式值：

constexpr double forceOfGravity = 9.8;
    constexpr double moonGravity = forceOfGravity / 6.0;

常数表示式的数据参数是隐式的常数。他们可以只存储常数表示式或常数表示式建构式的结果。

为了从用户自定类型(user-defined type)建构常数表示式的数据参数，建构式也可以被声明成 constexpr。与常数表示式函数一样，常数表示式的建构式必须在该编译单元内使用之前被定义。他必须有着空的函数本体。它必须用常数表示式初始化他的成员(member)。而这种类型的析构式应当是无意义的(trivial)，什么事都不做。

复制 constexpr 建构起来的类型也应该被定义为 constexpr，这样可以让他们从常数表示式的函数以值传回。类型的任何成员函数，像是复制建构式、重载的运算符等等，只要他们符合常数表示式函数的定义，都可以被声明成 constexpr。这使得编译器能够在编译期进行类型的复制、对他们施行运算等等。

常数表示式函数或建构式，可以以非常数表示式(non-constexpr)参数唤起。就如同 constexpr 整数字面值能够指派给 non-constexpr 参数，constexpr 函数也可以接受 non-constexpr 参数，其结果存储于 non-constexpr 参数。constexpr 关键字只有当表示式的成员都是 constexpr，才允许编译期常数性的可能。

### \[\]对POD定义的修正 ###

在标准C++，一个结构(struct)为了能够被当成[plain old data][] (POD)，必须遵守几条规则。有很好的理由使我们想让大量的类型符合这种定义，符合这种定义的类型能够允许产生与C兼容的对象布局(object layout)。然而，C++03的规则太严苛了。

C++11将会放宽关于POD的定义。

当class/struct是*极简的(trivial)*、属于*标准布局(standard-layout)*，以及他的所有非静态(non-static)成员都是POD时，会被视为POD。

一个极简的类型或结构符合以下定义：

1.  极简的默认建构式。这可以使用[默认建构式语法][Link 6]，例如SomeConstructor() = default;
2.  极简的复制建构式，可使用默认语法(default syntax)
3.  极简的赋值运算符，可使用默认语法(default syntax)
4.  极简的析构式，不可以是虚拟的(virtual)

一个标准布局(standard-layout)的类型或结构符合以下定义：

1.  只有非静态的(non-static)数据成员，且这些成员也是符合标准布局的类型
2.  对所有non-static成员有相同的访问控制(public, private, protected)
3.  没有虚函数
4.  没有虚拟基类
5.  只有符合标准布局的基类
6.  没有和第一个定义的non-static成员相同类型的基类
7.  若非没有带有non-static成员的基类，就是最底层(继承最末位)的类型没有non-static数据成员而且至多一个带有non-static成员的基类。基本上，在该类型的继承体系中只会有一个类型带有non-static成员。

## \[\]核心语言建构期表现的加强 ##

### \[\]外部模板 ###

在标准C++中，只要在编译单元内遇到被完整定义的模板，编译器都必须将其实例化(instantiate)。这会大大增加编译时间，特别是模板在许多编译单元内使用相同的参数实例化。看起来没有办法告诉C++不要引发模板的实例化。

C++11将会引入外部模板这一概念。C++已经有了强制编译器在特定位置开始实例化的语法：

template class std::vector<MyClass>;

而C++所缺乏的是阻止编译器在某个编译单元内实例化模板的能力。C++11将简单地扩充前文语法如下：

extern template class std::vector<MyClass>;

这样就告诉编译器*不要*在该编译单元内将该模板实例化。

## \[\]核心语言使用性的加强 ##

这些特色存在的主要目的是为了使C++能够更容易使用。 举凡可以增进类型安全，减少代码重复，不易误用代码之类的。

### \[\]初始化列表 ###

标准C++从C带来了初始化列表(initializer list)的概念。这个构想是结构或是数组能够依据成员在该结构内定义的顺序通过给予的一串引数来产生。这些初始化列表是递归的，所以结构的数组或是包含其他结构的结构可以使用它们。这对静态列表或是仅是把结构初始化为某值而言相当有用。C++有构造函数，能够重复对象的初始化。但单单只有那样并不足以取代这项特色的所有机能。在C++03中，只允许在严格遵守POD的定义和限制条件的结构及类型上使用这项机能，非POD的类型不能使用，就连相当有用的STL容器std::vector也不行。

C++11将会把初始化列表的概念绑到类型上，称作std::initializer\_list。这允许构造函数或其他函数像参数般地使用初始化列表。举例来说：

class SequenceClass
    {
         
    public:
      SequenceClass(std::initializer_list<int> list);
    };

这将允许SequenceClass由一连串的整数构造，就像：

SequenceClass someVar = {
         1, 4, 5, 6};

这个构造函数是种特殊的构造函数，称作初始化列表构造函数。有着这种构造函数的类型在统一初始化的时候会被特别对待。

类型std::initializer\_list<>是个第一级的C++11标准程序库类型。然而他们只能够经由C++11编译器通过\{\}语法的使用被静态地构造 。这个列表一经构造便可复制，虽然这只是copy-by-reference。初始化列表是常数；一旦被创建，其成员均不能被改变，成员中的数据也不能够被变动。

因为初始化列表是真实类型，除了类型构造式之外还能够被用在其他地方。正规的函数能够使用初始化列表作为引数。例如：

void FunctionName(std::initializer_list<float> list);
     
    FunctionName({
         1.0f, -3.45f, -0.4f});

标准容器也能够以这种方式初始化：

vector<string> v = {
          "xyzzy", "plugh", "abracadabra" };

### \[\]统一的初始化 ###

标准 C++ 在初始化类型方面有着许多问题。初始化类型有数种方法，而且交换使用时不会都产生相同结果。传统的建构式语法，看起来像是函数声明，而且为了能使编译器不会弄错必须采取一些步骤。只有集合体和 POD 类型能够被集合式的初始化(使用 `SomeType var = {/*stuff*/};`).

C++11 将会提供一种统一的语法初始化任意的对象，它扩充了初始化串行语法：

struct BasicStruct
    {
         
     int x;
     float y;
    };
     
    struct AltStruct
    {
         
      AltStruct(int _x, float _y) : x(_x), y(_y) {
         }
     
    private:
      int x;
      float y;
    };
     
    BasicStruct var1{
         5, 3.2f};
    AltStruct var2{
         2, 4.3f};

var1 的初始化的运作就如同 C-style 的初始化串行。每个公开的参数将被对应于初始化串行的值给初始化。隐式类型转换会在需要的时候被使用，这里的隐式类型转换不会产生范围缩限 (narrowing)。要是不能够转换，编译便会失败。(范围缩限 (narrowing)：转换后的类型无法表示原类型。如将 32-bit 的整数转换为 16-bit 或 8-bit 整数，或是浮点数转换为整数。) var2 的初始化则是简单地调用建构式。

统一的初始化建构能够免除具体指定特定类型的必要：

struct IdString
    {
         
      std::string name;
      int identifier;
    };
     
    IdString var3{
         "SomeName", 4};

该语法将会使用 const char \* 参数初始化 std::string 。你也可以做像下面的事：

IdString GetString()
    {
         
      return {
         "SomeName", 4}; // 注意這裡不需要明確的型別
    }

统一初始化不会取代建构式语法。仍然会有需要用到建构式语法的时候。如果一个类型拥有初始化串行建构式(TypeName(initializer\_list<SomeType>);)，而初始化串行符合 sequence 建构式的类型，那么它比其他形式的建构式的优先权都来的高。C++11 版本的 std::vector 将会有初始化串行建构式。这表示：

std::vector<int> theVec{
         4};

这将会调用初始化串行建构式，而不是调用std::vector只接受一个尺寸参数产生相应尺寸 vector 的建构式。要使用这个建构式，用户必须直接使用标准的建构式语法。

### \[\]类型推导 ###

在标准 C++(和 C )，使用参数必须明确的指出其类型。然而，随着模版类型的出现以及[模板元编程][Link 7]的技巧，某物的类型，特别是函数定义明确的回返类型，就不容易表示。在这样的情况下，将中间结果存储于参数是件困难的事，可能会需要知道特定的元编程程序库的内部情况。

C++11 提供两种方法缓解上述所遇到的困难。首先，有被明确初始化的参数可以使用 auto 关键字。这会依据该初始化子(initializer)的具体类型产生参数：

auto someStrangeCallableType = boost::bind(&SomeFunction, _2, _1, someObject);
    auto otherVariable = 5;

someStrangeCallableType 的类型就是模板函数 `boost::bind` 对特定引数所回返的类型。作为编译器语义分析责任的一部份，这个类型能够简单地被编译器决定，但用户要通过查看来判断类型就不是那么容易的一件事了。

otherVariable 的类型同样也是定义明确的，但用户很容易就能判别。它是个 int(整数)，就和整数字面值的类型一样。

除此之外，decltype 能够被用来在编译期决定一个表示式的类型。举例：

int someInt;
    decltype(someInt) otherIntegerVariable = 5;

decltype 和 auto 一起使用会更为有用，因为 auto 参数的类型只有编译器知道。然而 decltype 对于那些大量运用运算符重载和特化的类型的代码的表示也非常有用。

`auto` 对于减少冗赘的代码也很有用。举例而言，程序员不用写像下面这样：

for (vector<int>::const_iterator itr = myvec.cbegin(); itr != myvec.cend(); ++itr)

而可以用更简短的

for (auto itr = myvec.cbegin(); itr != myvec.cend(); ++itr)

这项差异随着程序员开始嵌套容器而更为显著，虽然在这种情况下 `typedef` 是一个减少代码的好方法。

decltype 所表示的类型可以和 auto 推导出来的不同。

#include <vector>
     
    int main()
    {
         
      const std::vector<int> v(1);
      auto a = v[0]；// a 為 int 型別
      decltype（v[0]) b = 0;   // b 為 const int& 型別，即
                          // std::vector<int>::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 循环 ###

Boost C++ 定义了许多"范围 (range) "的概念。范围表现有如受控制的串行 (list)，持有容器中的两点。有序容器是范围概念的超集 (superset)，有序容器中的两个[迭代器][Link 8] (iterator) 也能定义一个范围。这些概念以及操作的算法，将被并入 C++11 标准程序库。不过 C++11 将会以语言层次的支持来提供范围概念的效用。

for 述句将允许简单的范围迭代：

int my_array[5] = {
         1, 2, 3, 4, 5};
    for (int &x : my_array)
    {
         
      x *= 2;
    }

上面 for 述句的第一部份定义被用来做范围迭代的参数，就像被声明在一般 for 循环的参数一样，其作用域仅只于循环的范围。而在":"之后的第二区块，代表将被迭代的范围。这样一来，就有了能够允许 C-style 数组被转换成范围概念的概念图。这可以是 std::vector，或是其他符合范围概念的对象。

### \[\]Lambda函数与表示式 ###

在标准 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 ([闭包][Link 9])。

[]  // 沒有定義任何變數。使用未定義變數會導致錯誤。
    [x, &y] // x 以傳值方式傳入(預設)，y 以傳參考方式傳入。
    [&]   // 任何被使用到的外部變數皆隱式地以參考方式加以引用。
    [=]   // 任何被使用到的外部變數皆隱式地以傳值方式加以引用。
    [&, x]   // x 顯示地以傳值方式加以引用。其餘變數以參考方式加以引用。
    [=, &z]   // z 顯示地以參考方式加以引用。其餘變數以傳值方式加以引用。

closure 被定义与使用如下:

std::vector<int> someList;
    int total = 0;
    std::for_each(someList.begin(), someList.end(), [&total](int x) {
         
      total += x;
    });
    std::cout << total;

上例可计算 someList 元素的总和并将其印出。 参数 total 是 lambda 函数 closure 的一部分，同时它以引用方式被传递入谓词函数， 因此它的值可被 lambda 函数改变。

若不使用引用的符号*&*，则代表参数以传值的方式传入 lambda 函数。 让用户可以用这种表示法明确区分参数传递的方法：传值，或是传参考。 由于 lambda 函数可以不在被声明的地方就地使用(如置入 std::function 对象中)； 这种情况下，若参数是以传参考的方式链接到 closure 中，是无意义甚至是危险的行为。

若 lambda 函数只在定义的作用域使用， 则可以用 \[&\] 声明 lambda 函数， 代表所有引用到 stack 中的参数，都是以参考的方式传入， 不必一一显式指明：

std::vector<int> someList;
    int total = 0;
    std::for_each(someList.begin(), someList.end(), [&](int x) {
         
      total += x;
    });

参数传入 lambda 函数的方式可能随实做有所变化，一般期望的方法是 lambda 函数能保留其作用域函数的 stack 指针，借此访问区域参数。

若使用 \[=\] 而非 \[&\]，则代表所有的参考的参数都是传值使用。

对于不同的参数，传值或传参考可以混和使用。 比方说，用户可以让所有的参数都以传参考的方式使用，但带有一个传值使用的参数：

int total = 0;
    int value = 5;
    [&, value](int x) {
          total += (x * value); };

total 是传参考的方式传入 lambda 函数，而 value 则是传值。

若一个 lambda 函数被定义于某类型的成员函数中，会被当作该类型的 friend。像这样的 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 函数是以参考的方式获取到它所有的 closure 参数，或者是没有 closure 参数，那么所产生的函数对象会被给予一个特殊的类型:std::reference\_closure<R(P)>，其中 R(P) 是包含回返类型的函数签名。比起由 std::function 获取而来，这会是lambda函数更有效率的代表：

std::reference_closure<void()> myLambdaFunc = [this]() {
          this->SomePrivateMemberFunction(); };
    myLambdaFunc();

### \[\]另一种的函数语法 ###

[标准C][C 2] 函数声明语法对于C语言已经足够。 演化自 C 的 C++ 除了 C 的基础语法外，又扩充额外的语法。 然而，当 C++ 变得更为复杂时，它暴露出许多语法上的限制， 特别是针对函数模板的声明。 下面的示例，不是合法的 C++03：

template< typename LHS, typename RHS> 
      Ret AddingFunc(const LHS &lhs, const RHS &rhs) {
         return lhs + rhs;} //Ret的型別必須是(lhs+rhs)的型別

Ret 的类型由 LHS与RHS相加之后的结果的类型来决定。 即使使用 C++11 新加入的 decltype 来声明 AddingFunc 的返回类型，依然不可行。

template< typename LHS, typename RHS> 
      decltype(lhs+rhs) AddingFunc(const LHS &lhs, const RHS &rhs) {
         return lhs + rhs;} //不合法的 C++11

不合法的原因在于lhs 及 rhs 在定义前就出现了。 直到剖析器解析到函数原型的后半部，lhs 与 rhs 才是有意义的。

针对此问题，C++11 引进一种新的函数定义与声明的语法：

template< typename LHS, typename RHS> 
      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++中，建构式不能调用其它的建构式；每个建构式必须自己初始化所有的成员或是调用一个共用的成员函数。基类的建构式不能够直接作为派生类的建构式；就算基类的建构式已经足够，每个衍伸的类型仍必须实做自己的建构式。类型中non-constant的数据成员不能够在声明的地方被初始化，它们只能在建构式中被初始化。 C++11将会提供这些问题的解决方案。

C++11允许建构式调用其他建构式，这种做法称作委托或转接([delegation][])。 仅仅只需要加入少量的代码，就能让数个建构式之间达成功能复用(reuse)。[Java][]以及[C\#][C 3]都有提供这种功能。C++11 语法如下：

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

C++03中，建构式运行退出代表对象建构完成； 而允许使用转接建构式的 C++11 则是以"任何"一个建构式退出代表建构完成。 使用转接的建构式，函数本体中的代码将于被转接的建构式完成后继续运行(如上例的 PostInit())。 若基底类型使用了转接建构式，则派生类的建构式会在"所有"基底类型的建构式都完成后， 才会开始运行。

C++11 允许派生类手动继承基底类型的建构式， 编译器可以使用基底类型的建构式完成派生类的建构。 而将基类的建构式带入派生类的动作， 无法选择性地部分带入， 要不就是继承基类全部的建构式，要不就是一个都不继承(不手动带入)。 此外，若牵涉到多重继承，从多个基底类型继承而来的建构式不可以有相同的函数签名(signature)。 而派生类的新加入的建构式也不可以和继承而来的基底建构式有相同的函数签名，因为这相当于重复声明。

语法如下：

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

此语法等同于 DerivedClass 声明一个DerivedClass(int) 的建构式。 同时也因为 DerivedClass 有了一个继承而来的建构式，所以不会有默认建构式。

另一方面，C++11可以使用以下的语法完成成员初始化：

class SomeClass
    {
         
    public:
      SomeClass() {
         }
      explicit SomeClass(int iNewValue) : iValue(iNewValue) {
         }
     
    private:
      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 将加入支持用来防止上述情形产生，并在编译期而非运行期捕获此类错误。为保持向后兼容，此功能将是选择性的。其语法如下:

struct Base {
         
        virtual void some_func(float);
    };
     
    struct Derived : Base {
         
        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);

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
     
    foo(nullptr);           // 呼叫 foo(char *)

### \[\]强类型枚举 ###

在标准C++中，枚举类型不是类型安全的。枚举类型被视为整数，这使得两种不同的枚举类型之间可以进行比较。C++03 唯一提供的安全机制是一个整数或一个枚举型值不能隐式转换到另一个枚举别型。 此外，枚举所使用整数类型及其大小都由实现方法定义，皆无法明确指定。 最后，枚举的名称全数暴露于一般范围中，因此两个不同的枚举，不可以有相同的枚举名。 (好比 enum Side\{ Right, Left \}; 和 enum Thing\{ Wrong, Right \}; 不能一起使用。)

C++11 引进了一种特别的 "枚举类"，可以避免上述的问题。使用 enum class 的语法来声明：

enum class Enumeration
    {
         
      Val1,
      Val2,
      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++ 的剖析器一律将 ">>" 视为右移运算符。 但在样板定义式中，绝大多数的场合其实都代表两个连续右角括号。 为了避免剖析器误判，撰码时不能把右角括号连着写。

C++11 变更了剖析器的解读规则；当遇到连续的右角括号时，优先解析右角括号为样板引数的退出符号。 如果解读过程中出现普通括号("(" 与 ")")，这条规则产生变化：

template<bool bTest> SomeType;
    std::vector<SomeType<1>2>> x1;   // 解讀為 std::vector of "SomeType<true> 2>"，
                                     // 非法的表示式， 整數 1 被轉換為 bool 型別 true
    std::vector<SomeType<(1>2)>> x1; // 解讀為 std::vector of "SomeType<false>",
                                     // 合法的 C++11 表示式， (1>2) 被轉換為 bool 型別 false

### \[\]显式类型转换子 ###

C++ 为了避免用户自定的单引数建构式被当成隐式类型转换子，引入了关键字 explicit 修饰字。 但是，在编译器对对象调用隐式类型转换的部分，则没有任何着墨。 比方说，一个 smart pointer 类型具有一个operator bool()， 被定义成若该 smart pointer 保管任何资源或指针，则传回 true，反之传回 false。 遇到这样的代码时：if(smart\_ptr\_variable)，编译器可以借由 operator bool() 隐式转换成布林值， 和测试原生指针的方法一样。 但是这类隐式转换同样也会发生在非预期之处。由于 C++ 的 bool 类型也是算数类型，能隐式换为整数甚至是浮点数。 拿对象转换出的布林值做布林运算以外的数学运算，往往不是程序员想要的。

在 C++11 中，关键字 explicit 修饰符也能套用到类型转换子上。如同建构式一样，它能避免类型转换子被隐式转换调用。但 C++11 特别针对布林值转换提出规范，在 if 条件式，循环，逻辑运算等需要布林值的地方，编译器能为符合规范的表示式调用用户自定的布林类型转换子。

### \[\]模板的别名 ###

在进入这个主题之前，各位应该先弄清楚“模板”和“类型”本质上的不同。class template (类型模板，是模板)是用来产生 template class (模板类型，是类型)。  
在标准 C++，`typedef` 可定义模板类型一个新的类型名称，但是不能够使用 `typedef` 来定义模板的别名。举例来说：

template< typename first, typename second, int third>
    class SomeType;
     
    template< typename second>
    typedef SomeType<OtherType, second, 5> TypedefName; // 在C++是不合法的

这不能够通过编译。

为了定义模板的别名，C++11 将会增加以下的语法：

template< typename first, typename second, int third>
    class SomeType;
     
    template< typename second>
    using TypedefName = SomeType<OtherType, second, 5>;

using 也能在 C++11 中定义一般类型的别名，等同 typedef：

typedef void (*PFD)(double);            // 傳統語法
    using PFD = void (*)(double);           // 新增語法

### \[\]无限制的unions ###

在标准 C++ 中，并非任意的类型都能做为 union 的成员。比方说，带有 non-trivial 构造函数的类型就不能是 union 的成员。在新的标准里，移除了所有对 union 的使用限制，除了其成员仍然不能是引用类型。 这一改变使得 union 更强大，更有用，也易于使用。[\[1\]][1 1]

以下为 C++11 中 union 使用的简单样例：

struct point
    {
         
      point() {
         }
      point(int x, int y): x_(x), y_(y) {
         }
      int x_, y_;
    };
    union
    {
         
      int z;
      double w;
      point p;  // 不合法的 C++; point 有一 non-trivial 建構式
                // 合法的 C++11
    };

这一改变仅放宽 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<>
    struct count<> {
         
        static const int value = 0;
    };
     
    template<typename T, typename... Args>
    struct count<T, Args...> {
          
        static const int value = 1 + count<Args...>::value;
    };

虽然没有一个简洁的机制能够对[变长参数模板][Link 10]中的值进行迭代，但使用运算符"..."还能在代码各处对参数包施以更复杂的展开操作。举例来说，一个模板类的定义：

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 tr1::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: \u2018."

在'\\u'之后的是16个比特的十六进制数值；它不需要'0x'的前标。识别字'\\u'代表了一个16位的Unicode codepoint；如果要输入32位的codepoint，使用'\\U'和32个比特的十六进制数值。只有有效的Unicode codepoints能够被输入。举例而言，codepoints在范围U+D800—U+DFFF之间是被禁止的，它们被保留给UTF-16编码的surrogate pairs。

有时候避免手动将字符串换码也是很有用的，特别是在使用[XML][]文件或是一些[脚本语言][Link 11]的字面值的时候。 C++11将提供raw(未加工的)字符串字面值：

R"(The String Data \ Stuff " )"
    R"delimiter(The String Data \ Stuff " )delimiter"

在第一个例子中，任何包含在`(` `)`括号(标准已经从`[]`改为`()`)当中的都是字符串的一部分。其中`"`和`\`字符不需要经过跳脱(escaped)。在第二个例子中，`"delimiter(`开始字符串，只有在遇到`)delimiter"`才代表退出。其中`delimiter`可以是任意的字符串，能够允许用户在未加工的字符串字面值中使用`)`字符。 未加工的字符串字面值能够和宽字面值或是Unicode字面值结合：

u8R"XXX(I'm a "raw UTF-8" string.)XXX"
    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)][computing]

C++标准委员会计划统一对[多线程编程][Link 12]的支持。

这将涉及两个部分：第一、设计一个可以使多个线程在一个进程中共存的内存模型；第二、为线程之间的交互提供支持。第二部分将由程序库提供支持，更多请看[绪程支持][Link 13]。

在多个线程可能会访问相同内存的情形下，由一个内存模型对它们进行调度是非常有必要的。遵守模型规则的程序是被保证正确运行的，但违反规则的程序会发生不可预料的行为，这些行为依赖于[编译器的优化][Link 14]和内存一致性的问题。

### \[\]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`以及[前处理器][Link 15]指令`#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++，sizeof可以作用在对象以及类别上。但是不能够做以下的事：

struct SomeType {
          OtherType member; };
     
    sizeof(SomeType::member); // 直接由SomeType型別取得非靜態成員的大小，C++03不行。 C++11允許

这会传回OtherType的大小。C++03并不允许这样做，所以会引发编译错误。C++11将会允许这种使用。

### \[\]垃圾回收机制 ###

是否会自动回收那些无法被使用到 (unreachable) 的动态分配对象由实现决定。

## \[\]C++标准程序库的变更 ##

C++11 标准[程序库][Link 16]有数个新机能。其中许多可以在现行标准下实现，而另外一些则依赖于(或多或少)新的 C++11 核心语言机能。

新的程序库的大部分被定义于*[C++标准委员会的Library Technical Report][C_Library Technical Report]* (称TR1)，于2005年发布。各式 TR1 的完全或部分实现目前提供在[命名空间][Link 17]`std::tr1`。C++11 会将其移置于命名空间 `std` 之下。

### \[\]标准库组件上的升级 ###

目前的标准库能受益于 C++11 新增的一些语言特性。举例来说，对于大部份的标准库容器而言，像是搬移内含大量元素的容器，或是容器之内对元素的搬移，基于右值引用 (Rvalue reference) 的 `move` 构造函数都能优化前述动作。在适当的情况下，标准库组件将可利用 C++11 的语言特性进行升级。这些语言特性包含但不局限以下所列:

*  右值引用和其相关的 `move` 支持
 *  支持 UTF-16 编码，和 UTF-32 字符集
 *  变长参数模板 (与右值引用搭配可以达成完美转送 (perfect forwarding))
 *  编译期常数表达式
 *  `Decltype`
 *  显式类别转换子
 *  使用或禁用对象的默认函数

此外，自 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`。用户可以选择一个工作是要多个线程上异步的运行，或是在一个线程上运行并等待其所需要的数据。默认的情况，实现可以根据底层硬件选择前面两个选项的其中之一。另外在较简单的使用情形下，实现也可以利用线程池提供支持。

### \[\]多元组类别 ###

[多元组][Link 18]是一个内由数个异质对象以特定顺序排列而成的数据结构。多元组可被视为是 `struct` 其数据成员的一般化。

由 TR1 演进而来的 C++11 多元组类别将受益于 C++11 某些特色像是[变长参数模板][Link 5]。TR1 版本的多元组类别对所能容纳的对象个数会因实现而有所限制，且实现上需要用到大量的宏技巧。相反的，C++11 版本的多元组型基本上于对其能容纳的对象个数没有限制。然而，编译器对于模板实体化的递归深度上的限制仍旧影响了元组类别所能容纳的对象个数 (这是无法避免的情况); C++11 版本的多元组型不会把这个值让用户知道。

使用[变长参数模板][Link 5]，多元组类别的声明可以长得像下面这样:

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); 否则的话，赋值操作符右边的多元组其内含元素的类别必须能转换成左边的多元组其对应的元素类别，又或者赋值操作符左边的多元组其内含元素的类别必须定义适当的构造函数。

typedef std::tuple< int , double, string       > tuple_1 t1;
    typedef std::tuple< char, short , const char * > tuple_2 t2 ('X', 2, "Hola!");
    t1 = t2 ;  // 可行。前兩個元素會作型別轉換，
               // 第三個字串元素可由 'const char *' 所建構。

多元组类型对象的比较运算是可行的(当它们拥有同样数量的元素)。此外，C++11 提供两个表达式用来检查多元组类型的一些特性 (仅在编译期做此检查)。

*  `std::tuple_size<T>::value` 回传多元组 `T` 内的元素个数，
 *  `std::tuple_element<I, T>::type` 回传多元组 `T` 内的第 `I` 个元素的类别

### \[\]散列表 ###

在过去，不断有要求想将散列表(无序关系式容器)引进标准库。只因为时间上的限制，散列表才没有被标准库所采纳。虽然，散列表在最糟情况下(如果出现许多冲突 (collision) 的话)在性能上比不过平衡树。但实际运用上，散列表的表现则较佳。

因为标准委员会还看不到有任何机会能将开放寻址法标准化，所以目前冲突仅能通过[链地址法 (linear chaining)][_linear chaining] 的方式处理。为避免与第三方库发展的散列表发生名称上的冲突，前缀将采用 unordered 而非 hash。

库将引进四种散列表，其中差别在于底下两个特性: 是否接受具相同键值的项目 (Equivalent keys)，以及是否会将键值映射到相对应的数据 (Associated values)。

<table style="border-style:solid; border-color:rgb(170,170,170); font-size:15px; margin:1em 0px; background-color:rgb(249,249,249); border-collapse:collapse; color:rgb(0,0,0); font-family:sans-serif; line-height:22.0781px; text-align:center"> 
 <tbody> 
  <tr> 
   <th style="border-style:solid; border-color:rgb(170,170,170); padding:0.2em; background-color:rgb(242,242,242)"> 散列表类型</th> 
   <th style="border-style:solid; border-color:rgb(170,170,170); padding:0.2em; background-color:rgb(242,242,242)"> 有无关系值</th> 
   <th style="border-style:solid; border-color:rgb(170,170,170); padding:0.2em; background-color:rgb(242,242,242)"> 接受相同键值</th> 
  </tr> 
  <tr> 
   <td style="border-style:solid; border-color:rgb(170,170,170); padding:0.2em; text-align:left"> <code style="font-family:monospace,Courier">std::unordered_set</code></td> 
   <td style="border-style:solid; border-color:rgb(170,170,170); padding:0.2em; background-color:rgb(255,144,144); vertical-align:middle"> 否</td> 
   <td style="border-style:solid; border-color:rgb(170,170,170); padding:0.2em; background-color:rgb(255,144,144); vertical-align:middle"> 否</td> 
  </tr> 
  <tr> 
   <td style="border-style:solid; border-color:rgb(170,170,170); padding:0.2em; text-align:left"> <code style="font-family:monospace,Courier">std::unordered_multiset</code></td> 
   <td style="border-style:solid; border-color:rgb(170,170,170); padding:0.2em; background-color:rgb(255,144,144); vertical-align:middle"> 否</td> 
   <td style="border-style:solid; border-color:rgb(170,170,170); padding:0.2em; background-color:rgb(144,255,144); vertical-align:middle"> 是</td> 
  </tr> 
  <tr> 
   <td style="border-style:solid; border-color:rgb(170,170,170); padding:0.2em; text-align:left"> <code style="font-family:monospace,Courier">std::unordered_map</code></td> 
   <td style="border-style:solid; border-color:rgb(170,170,170); padding:0.2em; background-color:rgb(144,255,144); vertical-align:middle"> 是</td> 
   <td style="border-style:solid; border-color:rgb(170,170,170); padding:0.2em; background-color:rgb(255,144,144); vertical-align:middle"> 否</td> 
  </tr> 
  <tr> 
   <td style="border-style:solid; border-color:rgb(170,170,170); padding:0.2em; text-align:left"> <code style="font-family:monospace,Courier">std::unordered_multimap</code></td> 
   <td style="border-style:solid; border-color:rgb(170,170,170); padding:0.2em; background-color:rgb(144,255,144); vertical-align:middle"> 是</td> 
   <td style="border-style:solid; border-color:rgb(170,170,170); padding:0.2em; background-color:rgb(144,255,144); vertical-align:middle"> 是</td> 
  </tr> 
 </tbody> 
</table>

上述的类型将满足对一个容器类型的要求，同时也提供访问其中元素的成员函数: `insert`, `erase`, `begin`, `end`。

散列表不需要对现有核心语言做扩展(虽然散列表的实现会利用到 C++11 新的语言特性)，只会对头文件 `<functional>` 做些许扩展，并引入`<unordered_set>` 和 `<unordered_map>` 两个头文件。对于其它现有的类型不会有任何修改。同时，散列表也不会依赖其它标准库的扩展功能。

### \[\]正则表达式 ###

过去许多或多或少标准化的程序库被创建用来处理[正则表达式][Link 19]。有鉴于这些算法的使用非常普遍，因此标准程序库将会包含他们，并使用各种[面向对象语言][Link 20]的潜力。

这个新的程序库，被定义于`<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> 不需要改动到现有的头文件，同时也不需要对现有的语言作扩展。

### \[\]通用智能指针 ###

这些指针是由 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 标准库允许使用`rand`函数来生成[伪随机数][Link 21]。不过其算法则取决于各程序库开发者。 C++ 直接从 C 继承了这部份，但是 C++11 将会提供产生伪乱数的新方法。

C++11 的随机数功能分为两部分： 第一，一个乱数生成引擎，其中包含该生成引擎的状态，用来产生乱数。第二，一个分布，这可以用来决定产生乱数的范围，也可以决定以何种分布方式产生乱数。乱数生成对象即是由乱数生成引擎和分布所构成。

不同于 C 标准库的 `rand`; 针对产生乱数的机制，C++11 将会提供三种算法，每一种算法都有其强项和弱项:

<table style="border-style:solid; border-color:rgb(170,170,170); font-size:15px; margin:1em 0px; background-color:rgb(249,249,249); border-collapse:collapse; color:rgb(0,0,0); font-family:sans-serif; line-height:22.0781px"> 
 <tbody> 
  <tr> 
   <th style="border-style:solid; border-color:rgb(170,170,170); padding:0.2em; background-color:rgb(242,242,242); text-align:center"> 样板类</th> 
   <th style="border-style:solid; border-color:rgb(170,170,170); padding:0.2em; background-color:rgb(242,242,242); text-align:center"> 整数/浮点数</th> 
   <th style="border-style:solid; border-color:rgb(170,170,170); padding:0.2em; background-color:rgb(242,242,242); text-align:center"> 质量</th> 
   <th style="border-style:solid; border-color:rgb(170,170,170); padding:0.2em; background-color:rgb(242,242,242); text-align:center"> 速度</th> 
   <th style="border-style:solid; border-color:rgb(170,170,170); padding:0.2em; background-color:rgb(242,242,242); text-align:center"> 状态数*</th> 
  </tr> 
  <tr> 
   <th style="border-style:solid; border-color:rgb(170,170,170); padding:0.2em; background-color:rgb(242,242,242); text-align:center"> linear_congruential</th> 
   <td align="center" style="border-style:solid; border-color:rgb(170,170,170); padding:0.2em"> 整数</td> 
   <td align="center" style="border-style:solid; border-color:rgb(170,170,170); padding:0.2em"> 低</td> 
   <td align="center" style="border-style:solid; border-color:rgb(170,170,170); padding:0.2em"> 中等<sup><a href="https://zh.wikipedia.org/wiki/Wikipedia:%E5%88%97%E6%98%8E%E6%9D%A5%E6%BA%90" title="Wikipedia:列明来源" style="text-decoration:none; color:rgb(11,0,128)" rel="nofollow"><span title="来源请求开始于2009年4月26日。" style="white-space:nowrap">[来源请求]</span></a></sup></td> 
   <td align="center" style="border-style:solid; border-color:rgb(170,170,170); padding:0.2em"> 1</td> 
  </tr> 
  <tr> 
   <th style="border-style:solid; border-color:rgb(170,170,170); padding:0.2em; background-color:rgb(242,242,242); text-align:center"> subtract_with_carry</th> 
   <td align="center" style="border-style:solid; border-color:rgb(170,170,170); padding:0.2em"> 两者皆可</td> 
   <td align="center" style="border-style:solid; border-color:rgb(170,170,170); padding:0.2em"> 中等</td> 
   <td align="center" style="border-style:solid; border-color:rgb(170,170,170); padding:0.2em"> 快</td> 
   <td align="center" style="border-style:solid; border-color:rgb(170,170,170); padding:0.2em"> 25</td> 
  </tr> 
  <tr> 
   <th style="border-style:solid; border-color:rgb(170,170,170); padding:0.2em; background-color:rgb(242,242,242); text-align:center"> mersenne_twister</th> 
   <td align="center" style="border-style:solid; border-color:rgb(170,170,170); padding:0.2em"> 整数</td> 
   <td align="center" style="border-style:solid; border-color:rgb(170,170,170); padding:0.2em"> 佳</td> 
   <td align="center" style="border-style:solid; border-color:rgb(170,170,170); padding:0.2em"> 快</td> 
   <td align="center" style="border-style:solid; border-color:rgb(170,170,170); padding:0.2em"> 624</td> 
  </tr> 
 </tbody> 
</table>

C++11 将会提供一些标准分布: uniform\_int\_distribution ([离散型均匀分布][Link 22])，bernoulli\_distribution ([伯努利分布][Link 23])，geometric\_distribution ([几何分布][Link 24])， poisson\_distribution ([卜瓦松分布][Link 25])，binomial\_distribution ([二项分布][Link 26])，uniform\_real\_distribution ([离散型均匀分布][Link 22])， exponential\_distribution ([指数分布][Link 27])，normal\_distribution ([正态分布][Link 28]) 和 gamma\_distribution ([伽玛分布][Link 29])。

底下描述一个乱数生成对象如何由乱数生成引擎和分布构成:

std::uniform_int_distribution<int> distribution(0, 99); // 以離散型均勻分佈方式產生 int 亂數，範圍落在 0 到 99 之間
    std::mt19937 engine; // 建立亂數生成引擎
    auto generator = std::bind(distribution, engine); // 利用 bind 將亂數生成引擎和分布組合成一個亂數生成物件
    int random = generator();  // 產生亂數

### \[\]包装引用 ###

我们可以通过实体化样板类 `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
    }

这项功能将加入头文件 `<utility>` 之中，而非通过扩展语言来得到这项功能。

### \[\]多态函数对象包装器 ###

针对函数对象的多态包装器(又称多态函数对象包装器)在语义和语法上和函数指针相似，但不像函数指针那么狭隘。只要能被调用，且其参数能与包装器兼容的都能以多态函数对象包装器称之(函数指针，成员函数指针或仿函数)。

通过以下例子，我们可以了解多态函数对象包装器的特性:

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>`，而不须更动到语言本身。

### \[\]用于元编程的类别属性 ###

对于那些能自行创建或修改本身或其它程序的程序，我们称之为[元编程][Link 30]。这种行为可以发生在编译或运行期。C++ 标准委员会已经决定引进一组由[模板][Link 31]实现的库，程序员可利用此一库于编译期进行元编程。

底下是一个以元编程来计算指数的例子:

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++ 模板支持[泛型][Link 32]，这使得代码能更紧凑和有用。然而，算法经常会需要目前作用的数据类别的信息。这种信息可以通过类别属性 (`type traits`) 于模板实体化时将该信息萃取出来。

类别属性能识别一个对象的种类和有关一个类别 (class) (或 struct) 的特征。头文件 `<type_traits>` 描述了我们能识别那些特征。

底下的例子说明了模板函数‘elaborate’是如何根据给定的数据类别，从而实体化某一特定的算法 (`algorithm.do_it`)。

// 演算法一
    template< bool B > struct Algorithm {
         
        template<class T1, class T2> int do_it (T1 &, T2 &)  {
          /*...*/ }
    };
     
    // 演算法二
    template<> struct Algorithm<true> {
         
        template<class T1, class T2> int do_it (T1, T2)  {
          /*...*/ }
    };
     
    // 根據給定的型別，實體化之後的 'elaborate' 會選擇演算法一或二
    template<class T1, class T2> 
    int elaborate (T1 A, T2 B) 
    {
         
        // 若 T1 為 int 且 T1 為 float，選用演算法二
        // 其它情況選用演算法一
        return Algorithm<std::is_integral<T1>::value && std::is_floating_point<T2>::value>::do_it( A, B ) ;
    }

通过定义在 `<type_transform>` 的类别属性，自定的类别转换是可能的 (在模板中，`static_cast` 和 `const_cast` 无法适用所有情况)。

此种编程技巧能写出优美、简洁的代码; 然而除错是此种编程技巧的弱处: 编译期的错误信息让人不知所云，运行期的除错更是困难。

### \[\]用于计算函数对象返回类型的统一方法 ###

要在编译期决定一个样板仿函数的回返值类别并不容易，特别是当回返值依赖于函数的参数时。举例来说:

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++11 标准的特色 ##

预计由 Technical Report 提供支持:

*  [模块][Link 33]
 *  十进制类别
 *  数学专用函数

延后讨论:

*  Concepts ([概念 (C++)][_C])
 *  更完整或必备的垃圾回收支持
 *  Reflection
 *  Macro Scopes

## \[\]被移除或废弃的特色 ##

*  循序点 ([sequence point][])，这个术语正被更为易懂的描述所取代。一个运算可以发生 (is sequenced before) 在另一个运算之前; 又或者两个运算彼此之间没有顺序关系 (are unsequenced)。
 *  [export][]
 *  [exception specification][]s
 *  [std::auto\_ptr][std_auto_ptr] 被 **std::unique\_ptr** 取代。
 *  仿函数基类别 (std::unary\_function, std::binary\_function)、函数指针适配器、类型成员指针适配器以及绑定器 (binder)。

## \[\]编译器实现 ##

C++编译器对C++11新特性的支持情况：

*  [Visual C++][Visual C] 2010 : [C++0x Core Language Features In VC10: The Table][C_0x Core Language Features In VC10_ The Table]
 *  [GCC][] 4.6 : [Status of Experimental C++0x Support in GCC 4.6][Status of Experimental C_0x Support in GCC 4.6]

## \[\]关系项目 ##

*  [C++ Technical Report 1][C_ Technical Report 1]
 *  [C11][]，C 编程语言的最新标准
 *  [C++1y][C_1y]，计划中的 C++ 标准

## \[\]参考资料 ##

1.  **[^][Link 34]** [N2544][]

### \[\]C++标准委员会文件 ###

*  [**^**][Link 35]  Doc No. [1401][]: Jan Kristoffersen (2002年10月21日) *Atomic operations with multi-threaded environments*
 *  [**^**][Link 36]  Doc No. [1402][]: Doug Gregor (2002年10月22日) *A Proposal to add a Polymorphic Function Object Wrapper to the Standard Library*
 *  [**^**][Link 37]  Doc No. [1403][]: Doug Gregor (2002年11月8日) *Proposal for adding tuple types into the standard library*
 *  [**^**][Link 38]  Doc No. [1424][]: John Maddock (2003年3月3日) *A Proposal to add Type Traits to the Standard Library*
 *  [**^**][Link 39]  Doc No. [1429][]: John Maddock (2003年3月3日) *A Proposal to add Regular Expression to the Standard Library*
 *  [**^**][Link 40]  Doc No. [1449][]: B. Stroustrup, G. Dos Reis, Mat Marcus, Walter E. Brown, Herb Sutter (2003年4月7日) *Proposal to add template aliases to C++*
 *  [**^**][Link 41]  Doc No. [1450][]: P. Dimov, B. Dawes, G. Colvin (2003年3月27日) *A Proposal to Add General Purpose Smart Pointers to the Library Technical Report (Revision 1)*
 *  [**^**][Link 42]  Doc No. [1452][]: Jens Maurer (April 10, 2003) *A Proposal to Add an Extensible Random Number Facility to the Standard Library (Revision 2)*
 *  [**^**][Link 43]  Doc No. [1453][]: D. Gregor, P. Dimov (April 9, 2003) *A proposal to add a reference wrapper to the standard library (revision 1)*
 *  [**^**][Link 44]  Doc No. [1454][]: Douglas Gregor, P. Dimov (April 9, 2003) *A uniform method for computing function object return types (revision 1)*
 *  [**^**][Link 45]  Doc No. [1456][]: Matthew Austern (April 9, 2003) *A Proposal to Add Hash Tables to the Standard Library (revision 4)*
 *  [**^**][Link 46]  Doc No. [1471][]: Daveed Vandevoorde (April 18, 2003) *Reflective Metaprogramming in C++*
 *  [**^**][Link 47]  Doc No. [1676][]: Bronek Kozicki (September 9, 2004) *Non-member overloaded copy assignment operator*
 *  [**^**][Link 48]  Doc No. [1704][]: Douglas Gregor, Jaakko J?rvi, Gary Powell (September 10, 2004) *Variadic Templates: Exploring the Design Space*
 *  [**^**][Link 49]  Doc No. [1705][]: J. J?rvi, B. Stroustrup, D. Gregor, J. Siek, G. Dos Reis (September 12, 2004) *Decltype (and auto)*
 *  [**^**][Link 50]  Doc No. [1717][]: Francis Glassborow, Lois Goldthwaite (November 5, 2004) *explicit class and default definitions*
 *  [**^**][Link 51]  Doc No. [1719][]: Herb Sutter, David E. Miller (October 21, 2004) *Strongly Typed Enums (revision 1)*
 *  [**^**][Link 52]  Doc No. [1720][]: R. Klarer, J. Maddock, B. Dawes, H. Hinnant (October 20, 2004) *Proposal to Add Static Assertions to the Core Language (Revision 3)*
 *  [**^**][Link 53]  Doc No. [1757][]: Daveed Vandevoorde (January 14, 2005) *Right Angle Brackets (Revision 2)*
 *  [**^**][Link 54]  Doc No. [1811][]: J. Stephen Adamczyk (April 29, 2005) *Adding the long long type to C++ (Revision 3)*
 *  [**^**][Link 55]  Doc No. [1815][]: Lawrence Crowl (May 2, 2005) *ISO C++ Strategic Plan for Multithreading*
 *  [**^**][Link 56]  Doc No. [1827][]: Chris Uzdavinis, Alisdair Meredith (August 29, 2005) *An Explicit Override Syntax for C++*
 *  [**^**][Link 57]  Doc No. [1834][]: Detlef Vollmann (June 24, 2005) *A Pleading for Reasonable Parallel Processing Support in C++*
 *  [**^**][Link 58]  Doc No. [1836][]: ISO/IEC DTR 19768 (June 24, 2005) *Draft Technical Report on C++ Library Extensions*
 *  [**^**][Link 59]  Doc No. [1886][]: Gabriel Dos Reis, Bjarne Stroustrup (October 20, 2005) *Specifying C++ concepts*
 *  [**^**][Link 60]  Doc No. [1891][]: Walter E. Brown (October 18, 2005) *Progress toward Opaque Typedefs for C++0X*
 *  [**^**][Link 61]  Doc No. [1898][]: Michel Michaud, Michael Wong (October 6, 2004) *Forwarding and inherited constructors*
 *  [**^**][Link 62]  Doc No. [1919][]: Bjarne Stroustrup, Gabriel Dos Reis (December 11, 2005) *Initializer lists*
 *  [**^**][Link 63]  Doc No. [1968][]: V Samko; J Willcock, J J?rvi, D Gregor, A Lumsdaine (February 26, 2006) *Lambda expressions and closures for C++*
 *  [**^**][Link 64]  Doc No. [1986][]: Herb Sutter, Francis Glassborow (April 6, 2006) *Delegating Constructors (revision 3)*
 *  [**^**][Link 65]  Doc No. [2016][]: Hans Boehm, Nick Maclaren (April 21, 2002) *Should volatile Acquire Atomicity and Thread Visibility Semantics?*
 *  [**^**][Link 66]  Doc No. [2142][]: ISO/IEC DTR 19768 (January 12, 2007) *State of C++ Evolution (between Portland and Oxford 2007 Meetings)*
 *  [**^**][Link 67]  Doc No. [2228][]: ISO/IEC DTR 19768 (May 3, 2007) *State of C++ Evolution (Oxford 2007 Meetings)*
 *  [**^**][Link 68]  Doc No. [2258][]: G. Dos Reis and B. Stroustrup *Templates Aliases*
 *  [**^**][Link 69]  Doc No. [2280][]: Lawrence Crowl (May 2, 2007) *Thread-Local Storage*
 *  [**^**][Link 70]  Doc No. [2291][]: ISO/IEC DTR 19768 (June 25, 2007) *State of C++ Evolution (Toronto 2007 Meetings)*
 *  [**^**][Link 71]  Doc No. [2336][]: ISO/IEC DTR 19768 (July 29, 2007) *State of C++ Evolution (Toronto 2007 Meetings)*
 *  [**^**][Link 72]  Doc No. [2389][]: ISO/IEC DTR 19768 (August 7, 2007) *State of C++ Evolution (pre-Kona 2007 Meetings)*
 *  [**^**][Link 73]  Doc No. [2431][]: SC22/WG21/N2431 = J16/07-0301 (October 2, 2007), *A name for the null pointer: nullptr*
 *  [**^**][Link 74]  Doc No. [2432][]: ISO/IEC DTR 19768 (October 23, 2007) *State of C++ Evolution (post-Kona 2007 Meeting)*
 *  [**^**][Link 75]  Doc No. [2437][]: Lois Goldthwaite (October 5, 2007) *Explicit Conversion Operators*
 *  [**^**][Link 76]  Doc No. [2461][]: ISO/IEC DTR 19768 (October 22, 2007) *Working Draft, Standard for programming Language C++*
 *  [**^**][Link 77]  Doc No. [2507][]: ISO/IEC DTR 19768 (February 4, 2008) *State of C++ Evolution (pre-Bellevue 2008 Meeting)*
 *  [**^**][Link 78]  Doc No. [2544][N2544]: Alan Talbot, Lois Goldthwaite, Lawrence Crowl, Jens Maurer (February 29, 2008) *Unrestricted unions*
 *  [**^**][Link 79]  Doc No. [2565][]: ISO/IEC DTR 19768 (March 7, 2008) *State of C++ Evolution (post-Bellevue 2008 Meeting)*
 *  [**^**][Link 80]  Doc No. [2597][]: ISO/IEC DTR 19768 (April 29, 2008) *State of C++ Evolution (pre-Antipolis 2008 Meeting)*
 *  [**^**][Link 81]  Doc No. [2606][]: ISO/IEC DTR 19768 (May 19, 2008) *Working Draft, Standard for Programming Language C++*
 *  [**^**][Link 82]  Doc No. [2697][]: ISO/IEC DTR 19768 (June 15, 2008) *Minutes of WG21 Meeting June 8–15, 2008*
 *  [**^**][Link 83]  Doc No. [2798][]: ISO/IEC DTR 19768 (October 4, 2008) *Working Draft, Standard for Programming Language C++*
 *  [**^**][Link 84]  Doc No. [2857][]: ISO/IEC DTR 19768 (March 23, 2009) *Working Draft, Standard for Programming Language C++*
 *  [**^**][Link 85]  Doc No. [2869][]: ISO/IEC DTR 19768 (April 28, 2009) *State of C++ Evolution (post-San Francisco 2008 Meeting)*
 *  [**^**][Link 86]  Doc No. [3000][]: ISO/ISC DTR 19769 (November 9, 2009) *Working Draft, Standard for Programming Language C++*
 *  [**^**][Link 87]  Doc No. [3014][]: Stephen D. Clamage (November 4, 2009) *AGENDA, PL22.16 Meeting No. 53, WG21 Meeting No. 48, March 8–13, 2010, Pittsburgh, PA*
 *  [**^**][Link 88]  Doc No. [3082][]: Herb Sutter (2010年3月13日) *C++0x Meeting Schedule*
 *  [**^**][Link 89]  Doc No. [3092][]: ISO/ISC DTR 19769 (2010年3月26日) *Working Draft, Standard for Programming Language C++*
 *  [**^**][Link 90]  Doc No. [3126][]: ISO/ISC DTR 19769 (2010年8月21日) *Working Draft, Standard for Programming Language C++*
 *  [**^**][Link 91]  Doc No. [3225][]: ISO/ISC DTR 19769 (2010年11月27日) *Working Draft, Standard for Programming Language C++*
 *  [**^**][Link 92]  Doc No. [3242][]: ISO/ISC DTR 19769 (2011年2月28日) *Working Draft, Standard for Programming Language C++*
 *  [**^**][Link 93]  Doc No. [3290][]: ISO/ISC DTR 19769 (2011年4月11日) *Working Draft, Standard for Programming Language C++*

### \[\]文章 ###

*  [**a**][a] [**b**][b] The C++ Source Bjarne Stroustrup(2006年1月2日)*A Brief Look at C++0x*
 *  [**^**][Link 94]  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][C_0x_ The Dawning of a New Standard]

## \[\]外部链接 ##

*  [**The C++ Standards** Committee][The C_ Standards_Committee]
 *  [Bjarne Stroustrup's homepage][Bjarne Stroustrup_s homepage]
 *  [C++0X: The New Face of Standard C++][C_0X_ The New Face of Standard C]
 *  [Herb Sutter's blog coverage of C++0X][Herb Sutter_s blog coverage of C_0X]
 *  [A talk on C++0x given by Bjarne Stroustrup at the University of Waterloo][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)][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)][The State of the Language_ An Interview with Bjarne Stroustrup _August 15_ 2008]
 *  [Working draft for the C++ language, October 4, 2008][2798]
 *

====================================================================================================================

# 2 . 特性介绍 #

## 2.1  Lambda表达式 ##

转自 [C++11 新特性：Lambda 表达式][C_11 _Lambda]

或许，Lambda 表达式算得上是 C++ 11 新增特性中最激动人心的一个。这个全新的特性听起来很深奥，但却是很多其他语言早已提供（比如 C\#）或者即将提供（比如 Java）的。简而言之，Lambda 表达式就是用于创建匿名函数的。GCC 4.5.x 和 Microsoft Visual Studio 早已提供了对 lambda 表达式的支持。在 GCC 4.7 中，默认是不开启 C++ 11 特性的，需要添加  -std=c++11 编译参数。而 VS2010 则默认开启。

为什么说 lambda 表达式如此激动人心呢？举一个例子。标准 C++ 库中有一个常用算法的库，其中提供了很多算法函数，比如 sort() 和 find()。这些函数通常需要提供一个“谓词函数 predicate function”。所谓谓词函数，就是进行一个操作用的临时函数。比如 find() 需要一个谓词，用于查找元素满足的条件；能够满足谓词函数的元素才会被查找出来。这样的谓词函数，使用临时的匿名函数，既可以减少函数数量，又会让代码变得清晰易读。

下面来看一个例子：

C++

<table style="margin-left: 0px; font-style: inherit; font-variant: inherit; font-weight: inherit; font-stretch: inherit; font-size: 12px; line-height: inherit; vertical-align: baseline; margin-top: 0px !important; margin-right: 0px !important; margin-bottom: 0px !important; padding: 0px !important; border: none !important; border-collapse: collapse !important; border-spacing: 0px !important; width: auto !important; background: none !important; table-layout: auto !important;"> 
 <tbody style="margin: 0px; padding: 0px; border: 0px; font-style: inherit; font-variant: inherit; font-weight: inherit; font-stretch: inherit;font-size:undefined; line-height: inherit; vertical-align: baseline;"> 
  <tr style="font-style: inherit; font-variant: inherit; font-weight: inherit; font-stretch: inherit;font-size:undefined; line-height: inherit; background: 0px center; margin: 0px !important; padding: 0px !important; border: none !important; vertical-align: top !important;"> 
   <td style="border: 0px; font-style: inherit; font-variant: inherit; font-weight: inherit; font-stretch: inherit;font-size:undefined; line-height: inherit; background-image: initial; background-position: 0px center; background-size: initial; background-repeat: initial; background-attachment: initial; background-origin: initial; background-clip: initial; margin: 0px !important; padding: 0px !important; font-family: Consolas, ConsolasRegular, &quot;Courier New&quot;, monospace !important; vertical-align: top !important; background-color: rgb(238, 238, 238) !important;"> 
    <div style="margin: 0px; padding-right: 0px; padding-left: 0px; border: 0px; font-style: inherit; font-variant: inherit; font-weight: inherit; font-stretch: inherit; vertical-align: baseline; background: 0px center; white-space: nowrap; padding-top: 5px !important; padding-bottom: 3px !important; line-height: 15px !important;"> 
     <div style="margin: 0px; padding: 0px 5px; border-top: 0px; border-right: 1px solid rgb(222, 222, 222) !important; border-bottom: 0px; border-left: 0px; border-image: initial; font-style: inherit; font-variant: inherit; font-weight: inherit !important; font-stretch: inherit; font-size: inherit !important; line-height: inherit !important; font-family: inherit; vertical-align: baseline; background: 0px center; text-align: right !important; height: inherit; min-width: 1.2em !important; color: rgb(170, 170, 170) !important;">
       1 
     </div> 
     <div style="margin: 0px; padding: 0px 5px; border-top: 0px; border-right: 1px solid rgb(222, 222, 222) !important; border-bottom: 0px; border-left: 0px; border-image: initial; font-style: inherit; font-variant: inherit; font-weight: inherit !important; font-stretch: inherit; font-size: inherit !important; line-height: inherit !important; font-family: inherit; vertical-align: baseline; background: 0px center; text-align: right !important; height: inherit; min-width: 1.2em !important; color: rgb(170, 170, 170) !important;">
       2 
     </div> 
     <div style="margin: 0px; padding: 0px 5px; border-top: 0px; border-right: 1px solid rgb(222, 222, 222) !important; border-bottom: 0px; border-left: 0px; border-image: initial; font-style: inherit; font-variant: inherit; font-weight: inherit !important; font-stretch: inherit; font-size: inherit !important; line-height: inherit !important; font-family: inherit; vertical-align: baseline; background: 0px center; text-align: right !important; height: inherit; min-width: 1.2em !important; color: rgb(170, 170, 170) !important;">
       3 
     </div> 
     <div style="margin: 0px; padding: 0px 5px; border-top: 0px; border-right: 1px solid rgb(222, 222, 222) !important; border-bottom: 0px; border-left: 0px; border-image: initial; font-style: inherit; font-variant: inherit; font-weight: inherit !important; font-stretch: inherit; font-size: inherit !important; line-height: inherit !important; font-family: inherit; vertical-align: baseline; background: 0px center; text-align: right !important; height: inherit; min-width: 1.2em !important; color: rgb(170, 170, 170) !important;">
       4 
     </div> 
     <div style="margin: 0px; padding: 0px 5px; border-top: 0px; border-right: 1px solid rgb(222, 222, 222) !important; border-bottom: 0px; border-left: 0px; border-image: initial; font-style: inherit; font-variant: inherit; font-weight: inherit !important; font-stretch: inherit; font-size: inherit !important; line-height: inherit !important; font-family: inherit; vertical-align: baseline; background: 0px center; text-align: right !important; height: inherit; min-width: 1.2em !important; color: rgb(170, 170, 170) !important;">
       5 
     </div> 
     <div style="margin: 0px; padding: 0px 5px; border-top: 0px; border-right: 1px solid rgb(222, 222, 222) !important; border-bottom: 0px; border-left: 0px; border-image: initial; font-style: inherit; font-variant: inherit; font-weight: inherit !important; font-stretch: inherit; font-size: inherit !important; line-height: inherit !important; font-family: inherit; vertical-align: baseline; background: 0px center; text-align: right !important; height: inherit; min-width: 1.2em !important; color: rgb(170, 170, 170) !important;">
       6 
     </div> 
     <div style="margin: 0px; padding: 0px 5px; border-top: 0px; border-right: 1px solid rgb(222, 222, 222) !important; border-bottom: 0px; border-left: 0px; border-image: initial; font-style: inherit; font-variant: inherit; font-weight: inherit !important; font-stretch: inherit; font-size: inherit !important; line-height: inherit !important; font-family: inherit; vertical-align: baseline; background: 0px center; text-align: right !important; height: inherit; min-width: 1.2em !important; color: rgb(170, 170, 170) !important;">
       7 
     </div> 
     <div style="margin: 0px; padding: 0px 5px; border-top: 0px; border-right: 1px solid rgb(222, 222, 222) !important; border-bottom: 0px; border-left: 0px; border-image: initial; font-style: inherit; font-variant: inherit; font-weight: inherit !important; font-stretch: inherit; font-size: inherit !important; line-height: inherit !important; font-family: inherit; vertical-align: baseline; background: 0px center; text-align: right !important; height: inherit; min-width: 1.2em !important; color: rgb(170, 170, 170) !important;">
       8 
     </div> 
     <div style="margin: 0px; padding: 0px 5px; border-top: 0px; border-right: 1px solid rgb(222, 222, 222) !important; border-bottom: 0px; border-left: 0px; border-image: initial; font-style: inherit; font-variant: inherit; font-weight: inherit !important; font-stretch: inherit; font-size: inherit !important; line-height: inherit !important; font-family: inherit; vertical-align: baseline; background: 0px center; text-align: right !important; height: inherit; min-width: 1.2em !important; color: rgb(170, 170, 170) !important;">
       9 
     </div> 
    </div></td> 
   <td style="border: 0px; font-style: inherit; font-variant: inherit; font-weight: inherit; font-stretch: inherit;font-size:undefined; line-height: inherit; background: 0px center; width: 582.4px; margin: 0px !important; padding: 0px !important; font-family: Consolas, ConsolasRegular, &quot;Courier New&quot;, monospace !important; vertical-align: top !important;"> 
    <div style="margin: 0px; padding-right: 0px; padding-left: 0px; font-style: inherit; font-variant: inherit; font-weight: inherit; font-stretch: inherit; vertical-align: baseline; white-space: pre; overflow: visible; tab-size: 4; padding-top: 5px !important; padding-bottom: 3px !important; border: none !important; line-height: 15px !important; background: none !important;"> 
     <div style="margin: 0px; padding: 0px 5px; border: 0px; font-style: inherit; font-variant: inherit; font-stretch: inherit; font-family: inherit; vertical-align: baseline; background: 0px center; height: inherit; font-weight: inherit !important; font-size: inherit !important; line-height: inherit !important;"> 
      <span style="margin: 0px; padding: 0px; border: 0px; font-style: inherit; font-variant: inherit; font-weight: inherit !important; font-stretch: inherit; font-size: inherit !important; line-height: inherit !important; font-family: inherit; vertical-align: baseline; height: inherit; color: rgb(184, 92, 0) !important;">#include &lt;algorithm&gt;</span> 
     </div> 
     <div style="margin: 0px; padding: 0px 5px; border: 0px; font-style: inherit; font-variant: inherit; font-stretch: inherit; font-family: inherit; vertical-align: baseline; background: 0px center; height: inherit; font-weight: inherit !important; font-size: inherit !important; line-height: inherit !important;"> 
      <span style="margin: 0px; padding: 0px; border: 0px; font-style: inherit; font-variant: inherit; font-weight: inherit !important; font-stretch: inherit; font-size: inherit !important; line-height: inherit !important; font-family: inherit; vertical-align: baseline; height: inherit; color: rgb(184, 92, 0) !important;">#include &lt;cmath&gt;</span> 
     </div> 
     <div style="margin: 0px; padding: 0px 5px; border: 0px; font-style: inherit; font-variant: inherit; font-stretch: inherit; font-family: inherit; vertical-align: baseline; background: 0px center; height: inherit; font-weight: inherit !important; font-size: inherit !important; line-height: inherit !important;">
       &nbsp; 
     </div> 
     <div style="margin: 0px; padding: 0px 5px; border: 0px; font-style: inherit; font-variant: inherit; font-stretch: inherit; font-family: inherit; vertical-align: baseline; background: 0px center; height: inherit; font-weight: inherit !important; font-size: inherit !important; line-height: inherit !important;"> 
      <span style="margin: 0px; padding: 0px; border: 0px; font-style: inherit; font-variant: inherit; font-weight: bold !important; font-stretch: inherit; font-size: inherit !important; line-height: inherit !important; font-family: inherit; vertical-align: baseline; height: inherit; color: rgb(128, 0, 128) !important;">void</span> 
      <span style="margin: 0px; padding: 0px; border: 0px; font-style: inherit; font-variant: inherit; font-weight: inherit !important; font-stretch: inherit; font-size: inherit !important; line-height: inherit !important; font-family: inherit; vertical-align: baseline; height: inherit; color: rgb(0, 111, 224) !important;"> </span> 
      <span style="margin: 0px; padding: 0px; border: 0px; font-style: inherit; font-variant: inherit; font-weight: inherit !important; font-stretch: inherit; font-size: inherit !important; line-height: inherit !important; font-family: inherit; vertical-align: baseline; height: inherit; color: teal !important;">abssort</span> 
      <span style="margin: 0px; padding: 0px; border: 0px; font-style: inherit; font-variant: inherit; font-weight: inherit !important; font-stretch: inherit; font-size: inherit !important; line-height: inherit !important; font-family: inherit; vertical-align: baseline; height: inherit; color: rgb(51, 51, 51) !important;">(</span> 
      <span style="margin: 0px; padding: 0px; border: 0px; font-style: inherit; font-variant: inherit; font-weight: bold !important; font-stretch: inherit; font-size: inherit !important; line-height: inherit !important; font-family: inherit; vertical-align: baseline; height: inherit; color: rgb(128, 0, 128) !important;">float</span> 
      <span style="margin: 0px; padding: 0px; border: 0px; font-style: inherit; font-variant: inherit; font-weight: inherit !important; font-stretch: inherit; font-size: inherit !important; line-height: inherit !important; font-family: inherit; vertical-align: baseline; height: inherit; color: rgb(0, 111, 224) !important;"> </span> 
      <span style="margin: 0px; padding: 0px; border: 0px; font-style: inherit; font-variant: inherit; font-weight: inherit !important; font-stretch: inherit; font-size: inherit !important; line-height: inherit !important; font-family: inherit; vertical-align: baseline; height: inherit; color: rgb(0, 111, 224) !important;">*</span> 
      <span style="margin: 0px; padding: 0px; border: 0px; font-style: inherit; font-variant: inherit; font-weight: inherit !important; font-stretch: inherit; font-size: inherit !important; line-height: inherit !important; font-family: inherit; vertical-align: baseline; height: inherit; color: rgb(0, 45, 122) !important;">x</span> 
      <span style="margin: 0px; padding: 0px; border: 0px; font-style: inherit; font-variant: inherit; font-weight: inherit !important; font-stretch: inherit; font-size: inherit !important; line-height: inherit !important; font-family: inherit; vertical-align: baseline; height: inherit; color: rgb(51, 51, 51) !important;">,</span> 
      <span style="margin: 0px; padding: 0px; border: 0px; font-style: inherit; font-variant: inherit; font-weight: inherit !important; font-stretch: inherit; font-size: inherit !important; line-height: inherit !important; font-family: inherit; vertical-align: baseline; height: inherit; color: rgb(0, 111, 224) !important;"> </span> 
      <span style="margin: 0px; padding: 0px; border: 0px; font-style: inherit; font-variant: inherit; font-weight: bold !important; font-stretch: inherit; font-size: inherit !important; line-height: inherit !important; font-family: inherit; vertical-align: baseline; height: inherit; color: rgb(128, 0, 128) !important;">unsigned</span> 
      <span style="margin: 0px; padding: 0px; border: 0px; font-style: inherit; font-variant: inherit; font-weight: inherit !important; font-stretch: inherit; font-size: inherit !important; line-height: inherit !important; font-family: inherit; vertical-align: baseline; height: inherit; color: rgb(0, 111, 224) !important;"> </span> 
      <span style="margin: 0px; padding: 0px; border: 0px; font-style: inherit; font-variant: inherit; font-weight: inherit !important; font-stretch: inherit; font-size: inherit !important; line-height: inherit !important; font-family: inherit; vertical-align: baseline; height: inherit; color: rgb(0, 45, 122) !important;">N</span> 
      <span style="margin: 0px; padding: 0px; border: 0px; font-style: inherit; font-variant: inherit; font-weight: inherit !important; font-stretch: inherit; font-size: inherit !important; line-height: inherit !important; font-family: inherit; vertical-align: baseline; height: inherit; color: rgb(51, 51, 51) !important;">)</span> 
     </div> 
     <div style="margin: 0px; padding: 0px 5px; border: 0px; font-style: inherit; font-variant: inherit; font-stretch: inherit; font-family: inherit; vertical-align: baseline; background: 0px center; height: inherit; font-weight: inherit !important; font-size: inherit !important; line-height: inherit !important;"> 
      <span style="margin: 0px; padding: 0px; border: 0px; font-style: inherit; font-variant: inherit; font-weight: inherit !important; font-stretch: inherit; font-size: inherit !important; line-height: inherit !important; font-family: inherit; vertical-align: baseline; height: inherit; color: rgb(51, 51, 51) !important;">{ </span> 
     </div> 
     <div style="margin: 0px; padding: 0px 5px; border: 0px; font-style: inherit; font-variant: inherit; font-stretch: inherit; font-family: inherit; vertical-align: baseline; background: 0px center; height: inherit; font-weight: inherit !important; font-size: inherit !important; line-height: inherit !important;"> 
      <span style="margin: 0px; padding: 0px; border: 0px; font-style: inherit; font-variant: inherit; font-weight: inherit !important; font-stretch: inherit; font-size: inherit !important; line-height: inherit !important; font-family: inherit; vertical-align: baseline; height: inherit; color: rgb(0, 111, 224) !important;">&nbsp;&nbsp;</span> 
      <span style="margin: 0px; padding: 0px; border: 0px; font-style: inherit; font-variant: inherit; font-weight: inherit !important; font-stretch: inherit; font-size: inherit !important; line-height: inherit !important; font-family: inherit; vertical-align: baseline; height: inherit; color: rgb(0, 45, 122) !important;">std</span> 
      <span style="margin: 0px; padding: 0px; border: 0px; font-style: inherit; font-variant: inherit; font-weight: inherit !important; font-stretch: inherit; font-size: inherit !important; line-height: inherit !important; font-family: inherit; vertical-align: baseline; height: inherit; color: rgb(0, 111, 224) !important;">::</span> 
      <span style="margin: 0px; padding: 0px; border: 0px; font-style: inherit; font-variant: inherit; font-weight: inherit !important; font-stretch: inherit; font-size: inherit !important; line-height: inherit !important; font-family: inherit; vertical-align: baseline; height: inherit; color: teal !important;">sort</span> 
      <span style="margin: 0px; padding: 0px; border: 0px; font-style: inherit; font-variant: inherit; font-weight: inherit !important; font-stretch: inherit; font-size: inherit !important; line-height: inherit !important; font-family: inherit; vertical-align: baseline; height: inherit; color: rgb(51, 51, 51) !important;">(</span> 
      <span style="margin: 0px; padding: 0px; border: 0px; font-style: inherit; font-variant: inherit; font-weight: inherit !important; font-stretch: inherit; font-size: inherit !important; line-height: inherit !important; font-family: inherit; vertical-align: baseline; height: inherit; color: rgb(0, 45, 122) !important;">x</span> 
      <span style="margin: 0px; padding: 0px; border: 0px; font-style: inherit; font-variant: inherit; font-weight: inherit !important; font-stretch: inherit; font-size: inherit !important; line-height: inherit !important; font-family: inherit; vertical-align: baseline; height: inherit; color: rgb(51, 51, 51) !important;">,</span> 
     </div> 
     <div style="margin: 0px; padding: 0px 5px; border: 0px; font-style: inherit; font-variant: inherit; font-stretch: inherit; font-family: inherit; vertical-align: baseline; background: 0px center; height: inherit; font-weight: inherit !important; font-size: inherit !important; line-height: inherit !important;"> 
      <span style="margin: 0px; padding: 0px; border: 0px; font-style: inherit; font-variant: inherit; font-weight: inherit !important; font-stretch: inherit; font-size: inherit !important; line-height: inherit !important; font-family: inherit; vertical-align: baseline; height: inherit; color: rgb(0, 111, 224) !important;">&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;</span> 
      <span style="margin: 0px; padding: 0px; border: 0px; font-style: inherit; font-variant: inherit; font-weight: inherit !important; font-stretch: inherit; font-size: inherit !important; line-height: inherit !important; font-family: inherit; vertical-align: baseline; height: inherit; color: rgb(0, 45, 122) !important;">x</span> 
      <span style="margin: 0px; padding: 0px; border: 0px; font-style: inherit; font-variant: inherit; font-weight: inherit !important; font-stretch: inherit; font-size: inherit !important; line-height: inherit !important; font-family: inherit; vertical-align: baseline; height: inherit; color: rgb(0, 111, 224) !important;"> </span> 
      <span style="margin: 0px; padding: 0px; border: 0px; font-style: inherit; font-variant: inherit; font-weight: inherit !important; font-stretch: inherit; font-size: inherit !important; line-height: inherit !important; font-family: inherit; vertical-align: baseline; height: inherit; color: rgb(0, 111, 224) !important;">+</span> 
      <span style="margin: 0px; padding: 0px; border: 0px; font-style: inherit; font-variant: inherit; font-weight: inherit !important; font-stretch: inherit; font-size: inherit !important; line-height: inherit !important; font-family: inherit; vertical-align: baseline; height: inherit; color: rgb(0, 111, 224) !important;"> </span> 
      <span style="margin: 0px; padding: 0px; border: 0px; font-style: inherit; font-variant: inherit; font-weight: inherit !important; font-stretch: inherit; font-size: inherit !important; line-height: inherit !important; font-family: inherit; vertical-align: baseline; height: inherit; color: rgb(0, 45, 122) !important;">N</span> 
      <span style="margin: 0px; padding: 0px; border: 0px; font-style: inherit; font-variant: inherit; font-weight: inherit !important; font-stretch: inherit; font-size: inherit !important; line-height: inherit !important; font-family: inherit; vertical-align: baseline; height: inherit; color: rgb(51, 51, 51) !important;">,</span> 
     </div> 
     <div style="margin: 0px; padding: 0px 5px; border: 0px; font-style: inherit; font-variant: inherit; font-stretch: inherit; font-family: inherit; vertical-align: baseline; background: 0px center; height: inherit; font-weight: inherit !important; font-size: inherit !important; line-height: inherit !important;"> 
      <span style="margin: 0px; padding: 0px; border: 0px; font-style: inherit; font-variant: inherit; font-weight: inherit !important; font-stretch: inherit; font-size: inherit !important; line-height: inherit !important; font-family: inherit; vertical-align: baseline; height: inherit; color: rgb(0, 111, 224) !important;">&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;</span> 
      <span style="margin: 0px; padding: 0px; border: 0px; font-style: inherit; font-variant: inherit; font-weight: inherit !important; font-stretch: inherit; font-size: inherit !important; line-height: inherit !important; font-family: inherit; vertical-align: baseline; height: inherit; color: rgb(51, 51, 51) !important;">[</span> 
      <span style="margin: 0px; padding: 0px; border: 0px; font-style: inherit; font-variant: inherit; font-weight: inherit !important; font-stretch: inherit; font-size: inherit !important; line-height: inherit !important; font-family: inherit; vertical-align: baseline; height: inherit; color: rgb(51, 51, 51) !important;">]</span> 
      <span style="margin: 0px; padding: 0px; border: 0px; font-style: inherit; font-variant: inherit; font-weight: inherit !important; font-stretch: inherit; font-size: inherit !important; line-height: inherit !important; font-family: inherit; vertical-align: baseline; height: inherit; color: rgb(51, 51, 51) !important;">(</span> 
      <span style="margin: 0px; padding: 0px; border: 0px; font-style: inherit; font-variant: inherit; font-weight: bold !important; font-stretch: inherit; font-size: inherit !important; line-height: inherit !important; font-family: inherit; vertical-align: baseline; height: inherit; color: rgb(128, 0, 128) !important;">float</span> 
      <span style="margin: 0px; padding: 0px; border: 0px; font-style: inherit; font-variant: inherit; font-weight: inherit !important; font-stretch: inherit; font-size: inherit !important; line-height: inherit !important; font-family: inherit; vertical-align: baseline; height: inherit; color: rgb(0, 111, 224) !important;"> </span> 
      <span style="margin: 0px; padding: 0px; border: 0px; font-style: inherit; font-variant: inherit; font-weight: inherit !important; font-stretch: inherit; font-size: inherit !important; line-height: inherit !important; font-family: inherit; vertical-align: baseline; height: inherit; color: rgb(0, 45, 122) !important;">a</span> 
      <span style="margin: 0px; padding: 0px; border: 0px; font-style: inherit; font-variant: inherit; font-weight: inherit !important; font-stretch: inherit; font-size: inherit !important; line-height: inherit !important; font-family: inherit; vertical-align: baseline; height: inherit; color: rgb(51, 51, 51) !important;">,</span> 
      <span style="margin: 0px; padding: 0px; border: 0px; font-style: inherit; font-variant: inherit; font-weight: inherit !important; font-stretch: inherit; font-size: inherit !important; line-height: inherit !important; font-family: inherit; vertical-align: baseline; height: inherit; color: rgb(0, 111, 224) !important;"> </span> 
      <span style="margin: 0px; padding: 0px; border: 0px; font-style: inherit; font-variant: inherit; font-weight: bold !important; font-stretch: inherit; font-size: inherit !important; line-height: inherit !important; font-family: inherit; vertical-align: baseline; height: inherit; color: rgb(128, 0, 128) !important;">float</span> 
      <span style="margin: 0px; padding: 0px; border: 0px; font-style: inherit; font-variant: inherit; font-weight: inherit !important; font-stretch: inherit; font-size: inherit !important; line-height: inherit !important; font-family: inherit; vertical-align: baseline; height: inherit; color: rgb(0, 111, 224) !important;"> </span> 
      <span style="margin: 0px; padding: 0px; border: 0px; font-style: inherit; font-variant: inherit; font-weight: inherit !important; font-stretch: inherit; font-size: inherit !important; line-height: inherit !important; font-family: inherit; vertical-align: baseline; height: inherit; color: rgb(0, 45, 122) !important;">b</span> 
      <span style="margin: 0px; padding: 0px; border: 0px; font-style: inherit; font-variant: inherit; font-weight: inherit !important; font-stretch: inherit; font-size: inherit !important; line-height: inherit !important; font-family: inherit; vertical-align: baseline; height: inherit; color: rgb(51, 51, 51) !important;">)</span> 
      <span style="margin: 0px; padding: 0px; border: 0px; font-style: inherit; font-variant: inherit; font-weight: inherit !important; font-stretch: inherit; font-size: inherit !important; line-height: inherit !important; font-family: inherit; vertical-align: baseline; height: inherit; color: rgb(0, 111, 224) !important;"> </span> 
      <span style="margin: 0px; padding: 0px; border: 0px; font-style: inherit; font-variant: inherit; font-weight: inherit !important; font-stretch: inherit; font-size: inherit !important; line-height: inherit !important; font-family: inherit; vertical-align: baseline; height: inherit; color: rgb(51, 51, 51) !important;">{ </span> 
      <span style="margin: 0px; padding: 0px; border: 0px; font-style: inherit; font-variant: inherit; font-weight: inherit !important; font-stretch: inherit; font-size: inherit !important; line-height: inherit !important; font-family: inherit; vertical-align: baseline; height: inherit; color: rgb(0, 111, 224) !important;"> </span> 
      <span style="margin: 0px; padding: 0px; border: 0px; font-style: inherit; font-variant: inherit; font-stretch: inherit; font-family: inherit; vertical-align: baseline; height: inherit; font-weight: bold !important; font-size: inherit !important; line-height: inherit !important;">return</span> 
      <span style="margin: 0px; padding: 0px; border: 0px; font-style: inherit; font-variant: inherit; font-weight: inherit !important; font-stretch: inherit; font-size: inherit !important; line-height: inherit !important; font-family: inherit; vertical-align: baseline; height: inherit; color: rgb(0, 111, 224) !important;"> </span> 
      <span style="margin: 0px; padding: 0px; border: 0px; font-style: inherit; font-variant: inherit; font-weight: inherit !important; font-stretch: inherit; font-size: inherit !important; line-height: inherit !important; font-family: inherit; vertical-align: baseline; height: inherit; color: rgb(0, 45, 122) !important;">std</span> 
      <span style="margin: 0px; padding: 0px; border: 0px; font-style: inherit; font-variant: inherit; font-weight: inherit !important; font-stretch: inherit; font-size: inherit !important; line-height: inherit !important; font-family: inherit; vertical-align: baseline; height: inherit; color: rgb(0, 111, 224) !important;">::</span> 
      <span style="margin: 0px; padding: 0px; border: 0px; font-style: inherit; font-variant: inherit; font-weight: inherit !important; font-stretch: inherit; font-size: inherit !important; line-height: inherit !important; font-family: inherit; vertical-align: baseline; height: inherit; color: teal !important;">abs</span> 
      <span style="margin: 0px; padding: 0px; border: 0px; font-style: inherit; font-variant: inherit; font-weight: inherit !important; font-stretch: inherit; font-size: inherit !important; line-height: inherit !important; font-family: inherit; vertical-align: baseline; height: inherit; color: rgb(51, 51, 51) !important;">(</span> 
      <span style="margin: 0px; padding: 0px; border: 0px; font-style: inherit; font-variant: inherit; font-weight: inherit !important; font-stretch: inherit; font-size: inherit !important; line-height: inherit !important; font-family: inherit; vertical-align: baseline; height: inherit; color: rgb(0, 45, 122) !important;">a</span> 
      <span style="margin: 0px; padding: 0px; border: 0px; font-style: inherit; font-variant: inherit; font-weight: inherit !important; font-stretch: inherit; font-size: inherit !important; line-height: inherit !important; font-family: inherit; vertical-align: baseline; height: inherit; color: rgb(51, 51, 51) !important;">)</span> 
      <span style="margin: 0px; padding: 0px; border: 0px; font-style: inherit; font-variant: inherit; font-weight: inherit !important; font-stretch: inherit; font-size: inherit !important; line-height: inherit !important; font-family: inherit; vertical-align: baseline; height: inherit; color: rgb(0, 111, 224) !important;"> </span> 
      <span style="margin: 0px; padding: 0px; border: 0px; font-style: inherit; font-variant: inherit; font-weight: inherit !important; font-stretch: inherit; font-size: inherit !important; line-height: inherit !important; font-family: inherit; vertical-align: baseline; height: inherit; color: rgb(0, 111, 224) !important;">&lt;</span> 
      <span style="margin: 0px; padding: 0px; border: 0px; font-style: inherit; font-variant: inherit; font-weight: inherit !important; font-stretch: inherit; font-size: inherit !important; line-height: inherit !important; font-family: inherit; vertical-align: baseline; height: inherit; color: rgb(0, 111, 224) !important;"> </span> 
      <span style="margin: 0px; padding: 0px; border: 0px; font-style: inherit; font-variant: inherit; font-weight: inherit !important; font-stretch: inherit; font-size: inherit !important; line-height: inherit !important; font-family: inherit; vertical-align: baseline; height: inherit; color: rgb(0, 45, 122) !important;">std</span> 
      <span style="margin: 0px; padding: 0px; border: 0px; font-style: inherit; font-variant: inherit; font-weight: inherit !important; font-stretch: inherit; font-size: inherit !important; line-height: inherit !important; font-family: inherit; vertical-align: baseline; height: inherit; color: rgb(0, 111, 224) !important;">::</span> 
      <span style="margin: 0px; padding: 0px; border: 0px; font-style: inherit; font-variant: inherit; font-weight: inherit !important; font-stretch: inherit; font-size: inherit !important; line-height: inherit !important; font-family: inherit; vertical-align: baseline; height: inherit; color: teal !important;">abs</span> 
      <span style="margin: 0px; padding: 0px; border: 0px; font-style: inherit; font-variant: inherit; font-weight: inherit !important; font-stretch: inherit; font-size: inherit !important; line-height: inherit !important; font-family: inherit; vertical-align: baseline; height: inherit; color: rgb(51, 51, 51) !important;">(</span> 
      <span style="margin: 0px; padding: 0px; border: 0px; font-style: inherit; font-variant: inherit; font-weight: inherit !important; font-stretch: inherit; font-size: inherit !important; line-height: inherit !important; font-family: inherit; vertical-align: baseline; height: inherit; color: rgb(0, 45, 122) !important;">b</span> 
      <span style="margin: 0px; padding: 0px; border: 0px; font-style: inherit; font-variant: inherit; font-weight: inherit !important; font-stretch: inherit; font-size: inherit !important; line-height: inherit !important; font-family: inherit; vertical-align: baseline; height: inherit; color: rgb(51, 51, 51) !important;">)</span> 
      <span style="margin: 0px; padding: 0px; border: 0px; font-style: inherit; font-variant: inherit; font-weight: inherit !important; font-stretch: inherit; font-size: inherit !important; line-height: inherit !important; font-family: inherit; vertical-align: baseline; height: inherit; color: rgb(51, 51, 51) !important;">;</span> 
      <span style="margin: 0px; padding: 0px; border: 0px; font-style: inherit; font-variant: inherit; font-weight: inherit !important; font-stretch: inherit; font-size: inherit !important; line-height: inherit !important; font-family: inherit; vertical-align: baseline; height: inherit; color: rgb(0, 111, 224) !important;"> </span> 
      <span style="margin: 0px; padding: 0px; border: 0px; font-style: inherit; font-variant: inherit; font-weight: inherit !important; font-stretch: inherit; font-size: inherit !important; line-height: inherit !important; font-family: inherit; vertical-align: baseline; height: inherit; color: rgb(51, 51, 51) !important;">}</span> 
      <span style="margin: 0px; padding: 0px; border: 0px; font-style: inherit; font-variant: inherit; font-weight: inherit !important; font-stretch: inherit; font-size: inherit !important; line-height: inherit !important; font-family: inherit; vertical-align: baseline; height: inherit; color: rgb(51, 51, 51) !important;">)</span> 
      <span style="margin: 0px; padding: 0px; border: 0px; font-style: inherit; font-variant: inherit; font-weight: inherit !important; font-stretch: inherit; font-size: inherit !important; line-height: inherit !important; font-family: inherit; vertical-align: baseline; height: inherit; color: rgb(51, 51, 51) !important;">;</span> 
     </div> 
     <div style="margin: 0px; padding: 0px 5px; border: 0px; font-style: inherit; font-variant: inherit; font-stretch: inherit; font-family: inherit; vertical-align: baseline; background: 0px center; height: inherit; font-weight: inherit !important; font-size: inherit !important; line-height: inherit !important;"> 
      <span style="margin: 0px; padding: 0px; border: 0px; font-style: inherit; font-variant: inherit; font-weight: inherit !important; font-stretch: inherit; font-size: inherit !important; line-height: inherit !important; font-family: inherit; vertical-align: baseline; height: inherit; color: rgb(51, 51, 51) !important;">}</span> 
     </div> 
    </div></td> 
  </tr> 
 </tbody> 
</table>

从上面的例子来看，尽管支持 lambda 表达式，但 C++ 的语法看起来却很“神奇”。lambda 表达式使用一对方括号作为开始的标识，类似于声明一个函数，只不过这个函数没有名字，也就是一个匿名函数。这个匿名函数接受两个参数，`a`和`b`；其返回值是一个 bool 类型的值，注意，返回值是自动推断的，不需要显式声明，不过这是有条件的！条件就是，lambda 表达式的语句只有一个 return。函数的作用是比较 a、b 的绝对值的大小。然后，在此例中，这个 lambda 表达式作为一个闭包被传递给 `std::sort()` 函数。

下面，我们来详细解释下这个神奇的语法到底代表着什么。

我们从另外一个例子开始：

C++

输出值是什么？3.5！注意，这是一个函数对象（由 lambda 表达式生成），其实参是 -3.5，返回值是参数的绝对值。lambda 表达式的返回值类型是语言自动推断的，因为`std::abs()`的返回值就是 float。注意，前面我们也提到了，只有当 lambda 表达式中的语句“足够简单”，才能自动推断返回值类型。

C++ 11 的这种语法，其实就是匿名函数声明之后马上调用（否则的话，如果这个匿名函数既不调用，又不作为闭包传递给其它函数，那么这个匿名函数就没有什么用处）。如果你觉得奇怪，那么来看看 JavaScript 的这种写法：

JavaScript

C++ 11 的写法完全类似 JavaScript 的语法。

如果我不想让 lambda 表达式自动推断类型，或者是 lambda 表达式的内容很复杂，不能自动推断怎么办？比如，`std::abs(float)`的返回值是 float，我想把它强制转型为 int。那么，此时，我们就必须显式指定 lambda 表达式返回值的类型：

C++

这个语句与前面的不同之处在于，lambda 表达式的返回时不是 float 而是 int。也就是说，上面语句的输出值是 3。返回值类型的概念同普通的函数返回值类型是完全一样的。

当我们想引用一个 lambda 表达式时，我们可以使用`auto`关键字，例如：

C++

`auto`关键字实际会将 lambda 表达式转换成一种类似于`std::function`的内部类型（但并不是`std::function`类型，虽然与`std::function`“兼容”）。所以，我们也可以这么写：

C++

如果你对`std::function<int()>`这种写法感到很神奇，可以查看 C++ 11 的有关`std::function`的用法。简单来说，`std::function<int()>`就是一个可调用对象模板类，代表一个可调用对象，接受 0 个参数，返回值是`int`。所以，当我们需要一个接受一个`double`作为参数，返回`int`的对象时，就可以写作：`std::function<int(double)>`。

引入 lambda 表达式的前导符是一对方括号，称为 lambda 引入符（lambda-introducer）。lambda 引入符是有其自己的作用的，不仅仅是表明一个 lambda 表达式的开始那么简单。lambda 表达式可以使用与其相同范围 scope 内的变量。这个引入符的作用就是表明，其后的 lambda 表达式以何种方式使用（正式的术语是“捕获”）这些变量（这些变量能够在 lambda 表达式中被捕获，其实就是构成了一个闭包）。目前为止，我们看到的仅仅是一个空的方括号，其实，这个引入符是相当灵活的。例如：

C++

其输出值是 4.5。\[=\] 意味着，lambda 表达式以传值的形式捕获同范围内的变量。另外一个例子：

C++

<table style="margin-left:0px; font-style:inherit; font-variant:inherit; font-weight:inherit; font-size:12px; line-height:inherit; vertical-align:baseline; margin-top:0px!important; margin-right:0px!important; margin-bottom:0px!important; padding:0px!important; border:none!important; border-collapse:collapse!important; border-spacing:0px!important; width:auto!important; background:none!important; table-layout:auto!important"> 
 <tbody style="margin:0px; padding:0px; border:0px; font-style:inherit; font-variant:inherit; font-weight:inherit; font-size:undefined; line-height:inherit; vertical-align:baseline"> 
  <tr style="font-style:inherit; font-variant:inherit; font-weight:inherit; font-size:undefined; line-height:inherit; background:0px center; margin:0px!important; padding:0px!important; border:none!important; vertical-align:top!important"> 
   <td style="border:0px; font-style:inherit; font-variant:inherit; font-weight:inherit; font-size:undefined; line-height:inherit; margin:0px!important; padding:0px!important; font-family:Consolas,ConsolasRegular,&quot;Courier New&quot;,monospace!important; vertical-align:top!important; background-color:rgb(238,238,238)!important"> 
    <div style="margin:0px; padding-right:0px; padding-left:0px; border:0px; font-style:inherit; font-variant:inherit; font-weight:inherit; vertical-align:baseline; background:0px center; white-space:nowrap; padding-top:5px!important; padding-bottom:3px!important; line-height:15px!important"> 
     <div style="margin:0px; padding:0px 5px; border-top:0px; border-right:1px solid rgb(222,222,222)!important; border-bottom:0px; border-left:0px; font-style:inherit; font-variant:inherit; font-weight:inherit!important; font-size:inherit!important; line-height:inherit!important; font-family:inherit; vertical-align:baseline; background:0px center; text-align:right!important; height:inherit; min-width:1.2em!important; color:rgb(170,170,170)!important">
       1 
     </div> 
     <div style="margin:0px; padding:0px 5px; border-top:0px; border-right:1px solid rgb(222,222,222)!important; border-bottom:0px; border-left:0px; font-style:inherit; font-variant:inherit; font-weight:inherit!important; font-size:inherit!important; line-height:inherit!important; font-family:inherit; vertical-align:baseline; background:0px center; text-align:right!important; height:inherit; min-width:1.2em!important; color:rgb(170,170,170)!important">
       2 
     </div> 
     <div style="margin:0px; padding:0px 5px; border-top:0px; border-right:1px solid rgb(222,222,222)!important; border-bottom:0px; border-left:0px; font-style:inherit; font-variant:inherit; font-weight:inherit!important; font-size:inherit!important; line-height:inherit!important; font-family:inherit; vertical-align:baseline; background:0px center; text-align:right!important; height:inherit; min-width:1.2em!important; color:rgb(170,170,170)!important">
       3 
     </div> 
    </div> </td> 
   <td style="border:0px; font-style:inherit; font-variant:inherit; font-weight:inherit; font-size:undefined; line-height:inherit; background:0px center; width:582.4px; margin:0px!important; padding:0px!important; font-family:Consolas,ConsolasRegular,&quot;Courier New&quot;,monospace!important; vertical-align:top!important"> 
    <div style="margin:0px; padding-right:0px; padding-left:0px; font-style:inherit; font-variant:inherit; font-weight:inherit; vertical-align:baseline; white-space:pre; overflow:visible; padding-top:5px!important; padding-bottom:3px!important; border:none!important; line-height:15px!important; background:none!important"> 
     <div style="margin:0px; padding:0px 5px; border:0px; font-style:inherit; font-variant:inherit; font-family:inherit; vertical-align:baseline; background:0px center; height:inherit; font-weight:inherit!important; font-size:inherit!important; line-height:inherit!important"> 
      <span style="margin:0px; padding:0px; border:0px; font-style:inherit; font-variant:inherit; font-weight:bold!important; font-size:inherit!important; line-height:inherit!important; font-family:inherit; vertical-align:baseline; height:inherit; color:rgb(128,0,128)!important">float</span> 
      <span style="margin:0px; padding:0px; border:0px; font-style:inherit; font-variant:inherit; font-weight:inherit!important; font-size:inherit!important; line-height:inherit!important; font-family:inherit; vertical-align:baseline; height:inherit; color:rgb(0,111,224)!important"> </span> 
      <span style="margin:0px; padding:0px; border:0px; font-style:inherit; font-variant:inherit; font-weight:inherit!important; font-size:inherit!important; line-height:inherit!important; font-family:inherit; vertical-align:baseline; height:inherit; color:rgb(0,45,122)!important">f0</span> 
      <span style="margin:0px; padding:0px; border:0px; font-style:inherit; font-variant:inherit; font-weight:inherit!important; font-size:inherit!important; line-height:inherit!important; font-family:inherit; vertical-align:baseline; height:inherit; color:rgb(0,111,224)!important"> </span> 
      <span style="margin:0px; padding:0px; border:0px; font-style:inherit; font-variant:inherit; font-weight:inherit!important; font-size:inherit!important; line-height:inherit!important; font-family:inherit; vertical-align:baseline; height:inherit; color:rgb(0,111,224)!important">=</span> 
      <span style="margin:0px; padding:0px; border:0px; font-style:inherit; font-variant:inherit; font-weight:inherit!important; font-size:inherit!important; line-height:inherit!important; font-family:inherit; vertical-align:baseline; height:inherit; color:rgb(0,111,224)!important"> </span> 
      <span style="margin:0px; padding:0px; border:0px; font-style:inherit; font-variant:inherit; font-weight:inherit!important; font-size:inherit!important; line-height:inherit!important; font-family:inherit; vertical-align:baseline; height:inherit; color:rgb(0,153,153)!important">1.0</span> 
      <span style="margin:0px; padding:0px; border:0px; font-style:inherit; font-variant:inherit; font-weight:inherit!important; font-size:inherit!important; line-height:inherit!important; font-family:inherit; vertical-align:baseline; height:inherit; color:rgb(51,51,51)!important">;</span> 
     </div> 
     <div style="margin:0px; padding:0px 5px; border:0px; font-style:inherit; font-variant:inherit; font-family:inherit; vertical-align:baseline; background:0px center; height:inherit; font-weight:inherit!important; font-size:inherit!important; line-height:inherit!important"> 
      <span style="margin:0px; padding:0px; border:0px; font-style:inherit; font-variant:inherit; font-weight:inherit!important; font-size:inherit!important; line-height:inherit!important; font-family:inherit; vertical-align:baseline; height:inherit; color:rgb(0,45,122)!important">std</span> 
      <span style="margin:0px; padding:0px; border:0px; font-style:inherit; font-variant:inherit; font-weight:inherit!important; font-size:inherit!important; line-height:inherit!important; font-family:inherit; vertical-align:baseline; height:inherit; color:rgb(0,111,224)!important">::</span> 
      <span style="margin:0px; padding:0px; border:0px; font-style:inherit; font-variant:inherit; font-family:inherit; vertical-align:baseline; height:inherit; font-weight:bold!important; font-size:inherit!important; line-height:inherit!important">cout</span> 
      <span style="margin:0px; padding:0px; border:0px; font-style:inherit; font-variant:inherit; font-weight:inherit!important; font-size:inherit!important; line-height:inherit!important; font-family:inherit; vertical-align:baseline; height:inherit; color:rgb(0,111,224)!important"> </span> 
      <span style="margin:0px; padding:0px; border:0px; font-style:inherit; font-variant:inherit; font-weight:inherit!important; font-size:inherit!important; line-height:inherit!important; font-family:inherit; vertical-align:baseline; height:inherit; color:rgb(0,111,224)!important">&lt;&lt;</span> 
      <span style="margin:0px; padding:0px; border:0px; font-style:inherit; font-variant:inherit; font-weight:inherit!important; font-size:inherit!important; line-height:inherit!important; font-family:inherit; vertical-align:baseline; height:inherit; color:rgb(0,111,224)!important"> </span> 
      <span style="margin:0px; padding:0px; border:0px; font-style:inherit; font-variant:inherit; font-weight:inherit!important; font-size:inherit!important; line-height:inherit!important; font-family:inherit; vertical-align:baseline; height:inherit; color:rgb(51,51,51)!important">[</span> 
      <span style="margin:0px; padding:0px; border:0px; font-style:inherit; font-variant:inherit; font-weight:inherit!important; font-size:inherit!important; line-height:inherit!important; font-family:inherit; vertical-align:baseline; height:inherit; color:rgb(0,111,224)!important">&amp;</span> 
      <span style="margin:0px; padding:0px; border:0px; font-style:inherit; font-variant:inherit; font-weight:inherit!important; font-size:inherit!important; line-height:inherit!important; font-family:inherit; vertical-align:baseline; height:inherit; color:rgb(51,51,51)!important">]</span> 
      <span style="margin:0px; padding:0px; border:0px; font-style:inherit; font-variant:inherit; font-weight:inherit!important; font-size:inherit!important; line-height:inherit!important; font-family:inherit; vertical-align:baseline; height:inherit; color:rgb(51,51,51)!important">(</span> 
      <span style="margin:0px; padding:0px; border:0px; font-style:inherit; font-variant:inherit; font-weight:bold!important; font-size:inherit!important; line-height:inherit!important; font-family:inherit; vertical-align:baseline; height:inherit; color:rgb(128,0,128)!important">float</span> 
      <span style="margin:0px; padding:0px; border:0px; font-style:inherit; font-variant:inherit; font-weight:inherit!important; font-size:inherit!important; line-height:inherit!important; font-family:inherit; vertical-align:baseline; height:inherit; color:rgb(0,111,224)!important"> </span> 
      <span style="margin:0px; padding:0px; border:0px; font-style:inherit; font-variant:inherit; font-weight:inherit!important; font-size:inherit!important; line-height:inherit!important; font-family:inherit; vertical-align:baseline; height:inherit; color:rgb(0,45,122)!important">f</span> 
      <span style="margin:0px; padding:0px; border:0px; font-style:inherit; font-variant:inherit; font-weight:inherit!important; font-size:inherit!important; line-height:inherit!important; font-family:inherit; vertical-align:baseline; height:inherit; color:rgb(51,51,51)!important">)</span> 
      <span style="margin:0px; padding:0px; border:0px; font-style:inherit; font-variant:inherit; font-weight:inherit!important; font-size:inherit!important; line-height:inherit!important; font-family:inherit; vertical-align:baseline; height:inherit; color:rgb(0,111,224)!important"> </span> 
      <span style="margin:0px; padding:0px; border:0px; font-style:inherit; font-variant:inherit; font-weight:inherit!important; font-size:inherit!important; line-height:inherit!important; font-family:inherit; vertical-align:baseline; height:inherit; color:rgb(51,51,51)!important">{ </span> 
      <span style="margin:0px; padding:0px; border:0px; font-style:inherit; font-variant:inherit; font-weight:inherit!important; font-size:inherit!important; line-height:inherit!important; font-family:inherit; vertical-align:baseline; height:inherit; color:rgb(0,111,224)!important"> </span> 
      <span style="margin:0px; padding:0px; border:0px; font-style:inherit; font-variant:inherit; font-family:inherit; vertical-align:baseline; height:inherit; font-weight:bold!important; font-size:inherit!important; line-height:inherit!important">return</span> 
      <span style="margin:0px; padding:0px; border:0px; font-style:inherit; font-variant:inherit; font-weight:inherit!important; font-size:inherit!important; line-height:inherit!important; font-family:inherit; vertical-align:baseline; height:inherit; color:rgb(0,111,224)!important"> </span> 
      <span style="margin:0px; padding:0px; border:0px; font-style:inherit; font-variant:inherit; font-weight:inherit!important; font-size:inherit!important; line-height:inherit!important; font-family:inherit; vertical-align:baseline; height:inherit; color:rgb(0,45,122)!important">f0</span> 
      <span style="margin:0px; padding:0px; border:0px; font-style:inherit; font-variant:inherit; font-weight:inherit!important; font-size:inherit!important; line-height:inherit!important; font-family:inherit; vertical-align:baseline; height:inherit; color:rgb(0,111,224)!important"> </span> 
      <span style="margin:0px; padding:0px; border:0px; font-style:inherit; font-variant:inherit; font-weight:inherit!important; font-size:inherit!important; line-height:inherit!important; font-family:inherit; vertical-align:baseline; height:inherit; color:rgb(0,111,224)!important">+=</span> 
      <span style="margin:0px; padding:0px; border:0px; font-style:inherit; font-variant:inherit; font-weight:inherit!important; font-size:inherit!important; line-height:inherit!important; font-family:inherit; vertical-align:baseline; height:inherit; color:rgb(0,111,224)!important"> </span> 
      <span style="margin:0px; padding:0px; border:0px; font-style:inherit; font-variant:inherit; font-weight:inherit!important; font-size:inherit!important; line-height:inherit!important; font-family:inherit; vertical-align:baseline; height:inherit; color:rgb(0,45,122)!important">std</span> 
      <span style="margin:0px; padding:0px; border:0px; font-style:inherit; font-variant:inherit; font-weight:inherit!important; font-size:inherit!important; line-height:inherit!important; font-family:inherit; vertical-align:baseline; height:inherit; color:rgb(0,111,224)!important">::</span> 
      <span style="margin:0px; padding:0px; border:0px; font-style:inherit; font-variant:inherit; font-weight:inherit!important; font-size:inherit!important; line-height:inherit!important; font-family:inherit; vertical-align:baseline; height:inherit; color:teal!important">abs</span> 
      <span style="margin:0px; padding:0px; border:0px; font-style:inherit; font-variant:inherit; font-weight:inherit!important; font-size:inherit!important; line-height:inherit!important; font-family:inherit; vertical-align:baseline; height:inherit; color:rgb(51,51,51)!important">(</span> 
      <span style="margin:0px; padding:0px; border:0px; font-style:inherit; font-variant:inherit; font-weight:inherit!important; font-size:inherit!important; line-height:inherit!important; font-family:inherit; vertical-align:baseline; height:inherit; color:rgb(0,45,122)!important">f</span> 
      <span style="margin:0px; padding:0px; border:0px; font-style:inherit; font-variant:inherit; font-weight:inherit!important; font-size:inherit!important; line-height:inherit!important; font-family:inherit; vertical-align:baseline; height:inherit; color:rgb(51,51,51)!important">)</span> 
      <span style="margin:0px; padding:0px; border:0px; font-style:inherit; font-variant:inherit; font-weight:inherit!important; font-size:inherit!important; line-height:inherit!important; font-family:inherit; vertical-align:baseline; height:inherit; color:rgb(51,51,51)!important">;</span> 
      <span style="margin:0px; padding:0px; border:0px; font-style:inherit; font-variant:inherit; font-weight:inherit!important; font-size:inherit!important; line-height:inherit!important; font-family:inherit; vertical-align:baseline; height:inherit; color:rgb(0,111,224)!important"> </span> 
      <span style="margin:0px; padding:0px; border:0px; font-style:inherit; font-variant:inherit; font-weight:inherit!important; font-size:inherit!important; line-height:inherit!important; font-family:inherit; vertical-align:baseline; height:inherit; color:rgb(51,51,51)!important">}</span> 
      <span style="margin:0px; padding:0px; border:0px; font-style:inherit; font-variant:inherit; font-weight:inherit!important; font-size:inherit!important; line-height:inherit!important; font-family:inherit; vertical-align:baseline; height:inherit; color:rgb(0,111,224)!important"> </span> 
      <span style="margin:0px; padding:0px; border:0px; font-style:inherit; font-variant:inherit; font-weight:inherit!important; font-size:inherit!important; line-height:inherit!important; font-family:inherit; vertical-align:baseline; height:inherit; color:rgb(51,51,51)!important">(</span> 
      <span style="margin:0px; padding:0px; border:0px; font-style:inherit; font-variant:inherit; font-weight:inherit!important; font-size:inherit!important; line-height:inherit!important; font-family:inherit; vertical-align:baseline; height:inherit; color:rgb(0,111,224)!important">-</span> 
      <span style="margin:0px; padding:0px; border:0px; font-style:inherit; font-variant:inherit; font-weight:inherit!important; font-size:inherit!important; line-height:inherit!important; font-family:inherit; vertical-align:baseline; height:inherit; color:rgb(0,153,153)!important">3.5</span> 
      <span style="margin:0px; padding:0px; border:0px; font-style:inherit; font-variant:inherit; font-weight:inherit!important; font-size:inherit!important; line-height:inherit!important; font-family:inherit; vertical-align:baseline; height:inherit; color:rgb(51,51,51)!important">)</span> 
      <span style="margin:0px; padding:0px; border:0px; font-style:inherit; font-variant:inherit; font-weight:inherit!important; font-size:inherit!important; line-height:inherit!important; font-family:inherit; vertical-align:baseline; height:inherit; color:rgb(51,51,51)!important">;</span> 
     </div> 
     <div style="margin:0px; padding:0px 5px; border:0px; font-style:inherit; font-variant:inherit; font-family:inherit; vertical-align:baseline; background:0px center; height:inherit; font-weight:inherit!important; font-size:inherit!important; line-height:inherit!important"> 
      <span style="margin:0px; padding:0px; border:0px; font-style:inherit; font-variant:inherit; font-weight:inherit!important; font-size:inherit!important; line-height:inherit!important; font-family:inherit; vertical-align:baseline; height:inherit; color:rgb(0,45,122)!important">std</span> 
      <span style="margin:0px; padding:0px; border:0px; font-style:inherit; font-variant:inherit; font-weight:inherit!important; font-size:inherit!important; line-height:inherit!important; font-family:inherit; vertical-align:baseline; height:inherit; color:rgb(0,111,224)!important">::</span> 
      <span style="margin:0px; padding:0px; border:0px; font-style:inherit; font-variant:inherit; font-family:inherit; vertical-align:baseline; height:inherit; font-weight:bold!important; font-size:inherit!important; line-height:inherit!important">cout</span> 
      <span style="margin:0px; padding:0px; border:0px; font-style:inherit; font-variant:inherit; font-weight:inherit!important; font-size:inherit!important; line-height:inherit!important; font-family:inherit; vertical-align:baseline; height:inherit; color:rgb(0,111,224)!important"> </span> 
      <span style="margin:0px; padding:0px; border:0px; font-style:inherit; font-variant:inherit; font-weight:inherit!important; font-size:inherit!important; line-height:inherit!important; font-family:inherit; vertical-align:baseline; height:inherit; color:rgb(0,111,224)!important">&lt;&lt;</span> 
      <span style="margin:0px; padding:0px; border:0px; font-style:inherit; font-variant:inherit; font-weight:inherit!important; font-size:inherit!important; line-height:inherit!important; font-family:inherit; vertical-align:baseline; height:inherit; color:rgb(0,111,224)!important"> </span> 
      <span style="margin:0px; padding:0px; border:0px; font-style:inherit; font-variant:inherit; font-weight:inherit!important; font-size:inherit!important; line-height:inherit!important; font-family:inherit; vertical-align:baseline; height:inherit; color:rgb(221,17,68)!important">'\n'</span> 
      <span style="margin:0px; padding:0px; border:0px; font-style:inherit; font-variant:inherit; font-weight:inherit!important; font-size:inherit!important; line-height:inherit!important; font-family:inherit; vertical-align:baseline; height:inherit; color:rgb(0,111,224)!important"> </span> 
      <span style="margin:0px; padding:0px; border:0px; font-style:inherit; font-variant:inherit; font-weight:inherit!important; font-size:inherit!important; line-height:inherit!important; font-family:inherit; vertical-align:baseline; height:inherit; color:rgb(0,111,224)!important">&lt;&lt;</span> 
      <span style="margin:0px; padding:0px; border:0px; font-style:inherit; font-variant:inherit; font-weight:inherit!important; font-size:inherit!important; line-height:inherit!important; font-family:inherit; vertical-align:baseline; height:inherit; color:rgb(0,111,224)!important"> </span> 
      <span style="margin:0px; padding:0px; border:0px; font-style:inherit; font-variant:inherit; font-weight:inherit!important; font-size:inherit!important; line-height:inherit!important; font-family:inherit; vertical-align:baseline; height:inherit; color:rgb(0,45,122)!important">f0</span> 
      <span style="margin:0px; padding:0px; border:0px; font-style:inherit; font-variant:inherit; font-weight:inherit!important; font-size:inherit!important; line-height:inherit!important; font-family:inherit; vertical-align:baseline; height:inherit; color:rgb(0,111,224)!important"> </span> 
      <span style="margin:0px; padding:0px; border:0px; font-style:inherit; font-variant:inherit; font-weight:inherit!important; font-size:inherit!important; line-height:inherit!important; font-family:inherit; vertical-align:baseline; height:inherit; color:rgb(0,111,224)!important">&lt;&lt;</span> 
      <span style="margin:0px; padding:0px; border:0px; font-style:inherit; font-variant:inherit; font-weight:inherit!important; font-size:inherit!important; line-height:inherit!important; font-family:inherit; vertical-align:baseline; height:inherit; color:rgb(0,111,224)!important"> </span> 
      <span style="margin:0px; padding:0px; border:0px; font-style:inherit; font-variant:inherit; font-weight:inherit!important; font-size:inherit!important; line-height:inherit!important; font-family:inherit; vertical-align:baseline; height:inherit; color:rgb(221,17,68)!important">'\n'</span> 
      <span style="margin:0px; padding:0px; border:0px; font-style:inherit; font-variant:inherit; font-weight:inherit!important; font-size:inherit!important; line-height:inherit!important; font-family:inherit; vertical-align:baseline; height:inherit; color:rgb(51,51,51)!important">;</span> 
     </div> 
    </div> </td> 
  </tr> 
 </tbody> 
</table>

输出值是 4.5 和 4.5。\[&\] 表明，lambda 表达式以传引用的方式捕获外部变量。那么，下一个例子：

C++

<table style="margin-left: 0px; font-style: inherit; font-variant: inherit; font-weight: inherit; font-stretch: inherit; font-size: 12px; line-height: inherit; vertical-align: baseline; margin-top: 0px !important; margin-right: 0px !important; margin-bottom: 0px !important; padding: 0px !important; border: none !important; border-collapse: collapse !important; border-spacing: 0px !important; width: auto !important; background: none !important; table-layout: auto !important;"> 
 <tbody style="margin: 0px; padding: 0px; border: 0px; font-style: inherit; font-variant: inherit; font-weight: inherit; font-stretch: inherit;font-size:undefined; line-height: inherit; vertical-align: baseline;"> 
  <tr style="font-style: inherit; font-variant: inherit; font-weight: inherit; font-stretch: inherit;font-size:undefined; line-height: inherit; background: 0px center; margin: 0px !important; padding: 0px !important; border: none !important; vertical-align: top !important;"> 
   <td style="border: 0px; font-style: inherit; font-variant: inherit; font-weight: inherit; font-stretch: inherit;font-size:undefined; line-height: inherit; background-image: initial; background-position: 0px center; background-size: initial; background-repeat: initial; background-attachment: initial; background-origin: initial; background-clip: initial; margin: 0px !important; padding: 0px !important; font-family: Consolas, ConsolasRegular, &quot;Courier New&quot;, monospace !important; vertical-align: top !important; background-color: rgb(238, 238, 238) !important;"> 
    <div style="margin: 0px; padding-right: 0px; padding-left: 0px; border: 0px; font-style: inherit; font-variant: inherit; font-weight: inherit; font-stretch: inherit; vertical-align: baseline; background: 0px center; white-space: nowrap; padding-top: 5px !important; padding-bottom: 3px !important; line-height: 15px !important;"> 
     <div style="margin: 0px; padding: 0px 5px; border-top: 0px; border-right: 1px solid rgb(222, 222, 222) !important; border-bottom: 0px; border-left: 0px; border-image: initial; font-style: inherit; font-variant: inherit; font-weight: inherit !important; font-stretch: inherit; font-size: inherit !important; line-height: inherit !important; font-family: inherit; vertical-align: baseline; background: 0px center; text-align: right !important; height: inherit; min-width: 1.2em !important; color: rgb(170, 170, 170) !important;">
       1 
     </div> 
     <div style="margin: 0px; padding: 0px 5px; border-top: 0px; border-right: 1px solid rgb(222, 222, 222) !important; border-bottom: 0px; border-left: 0px; border-image: initial; font-style: inherit; font-variant: inherit; font-weight: inherit !important; font-stretch: inherit; font-size: inherit !important; line-height: inherit !important; font-family: inherit; vertical-align: baseline; background: 0px center; text-align: right !important; height: inherit; min-width: 1.2em !important; color: rgb(170, 170, 170) !important;">
       2 
     </div> 
     <div style="margin: 0px; padding: 0px 5px; border-top: 0px; border-right: 1px solid rgb(222, 222, 222) !important; border-bottom: 0px; border-left: 0px; border-image: initial; font-style: inherit; font-variant: inherit; font-weight: inherit !important; font-stretch: inherit; font-size: inherit !important; line-height: inherit !important; font-family: inherit; vertical-align: baseline; background: 0px center; text-align: right !important; height: inherit; min-width: 1.2em !important; color: rgb(170, 170, 170) !important;">
       3 
     </div> 
    </div></td> 
   <td style="border: 0px; font-style: inherit; font-variant: inherit; font-weight: inherit; font-stretch: inherit;font-size:undefined; line-height: inherit; background: 0px center; width: 582.4px; margin: 0px !important; padding: 0px !important; font-family: Consolas, ConsolasRegular, &quot;Courier New&quot;, monospace !important; vertical-align: top !important;"> 
    <div style="margin: 0px; padding-right: 0px; padding-left: 0px; font-style: inherit; font-variant: inherit; font-weight: inherit; font-stretch: inherit; vertical-align: baseline; white-space: pre; overflow: visible; tab-size: 4; padding-top: 5px !important; padding-bottom: 3px !important; border: none !important; line-height: 15px !important; background: none !important;"> 
     <div style="margin: 0px; padding: 0px 5px; border: 0px; font-style: inherit; font-variant: inherit; font-stretch: inherit; font-family: inherit; vertical-align: baseline; background: 0px center; height: inherit; font-weight: inherit !important; font-size: inherit !important; line-height: inherit !important;"> 
      <span style="margin: 0px; padding: 0px; border: 0px; font-style: inherit; font-variant: inherit; font-weight: bold !important; font-stretch: inherit; font-size: inherit !important; line-height: inherit !important; font-family: inherit; vertical-align: baseline; height: inherit; color: rgb(128, 0, 128) !important;">float</span> 
      <span style="margin: 0px; padding: 0px; border: 0px; font-style: inherit; font-variant: inherit; font-weight: inherit !important; font-stretch: inherit; font-size: inherit !important; line-height: inherit !important; font-family: inherit; vertical-align: baseline; height: inherit; color: rgb(0, 111, 224) !important;"> </span> 
      <span style="margin: 0px; padding: 0px; border: 0px; font-style: inherit; font-variant: inherit; font-weight: inherit !important; font-stretch: inherit; font-size: inherit !important; line-height: inherit !important; font-family: inherit; vertical-align: baseline; height: inherit; color: rgb(0, 45, 122) !important;">f0</span> 
      <span style="margin: 0px; padding: 0px; border: 0px; font-style: inherit; font-variant: inherit; font-weight: inherit !important; font-stretch: inherit; font-size: inherit !important; line-height: inherit !important; font-family: inherit; vertical-align: baseline; height: inherit; color: rgb(0, 111, 224) !important;"> </span> 
      <span style="margin: 0px; padding: 0px; border: 0px; font-style: inherit; font-variant: inherit; font-weight: inherit !important; font-stretch: inherit; font-size: inherit !important; line-height: inherit !important; font-family: inherit; vertical-align: baseline; height: inherit; color: rgb(0, 111, 224) !important;">=</span> 
      <span style="margin: 0px; padding: 0px; border: 0px; font-style: inherit; font-variant: inherit; font-weight: inherit !important; font-stretch: inherit; font-size: inherit !important; line-height: inherit !important; font-family: inherit; vertical-align: baseline; height: inherit; color: rgb(0, 111, 224) !important;"> </span> 
      <span style="margin: 0px; padding: 0px; border: 0px; font-style: inherit; font-variant: inherit; font-weight: inherit !important; font-stretch: inherit; font-size: inherit !important; line-height: inherit !important; font-family: inherit; vertical-align: baseline; height: inherit; color: rgb(0, 153, 153) !important;">1.0</span> 
      <span style="margin: 0px; padding: 0px; border: 0px; font-style: inherit; font-variant: inherit; font-weight: inherit !important; font-stretch: inherit; font-size: inherit !important; line-height: inherit !important; font-family: inherit; vertical-align: baseline; height: inherit; color: rgb(51, 51, 51) !important;">;</span> 
     </div> 
     <div style="margin: 0px; padding: 0px 5px; border: 0px; font-style: inherit; font-variant: inherit; font-stretch: inherit; font-family: inherit; vertical-align: baseline; background: 0px center; height: inherit; font-weight: inherit !important; font-size: inherit !important; line-height: inherit !important;"> 
      <span style="margin: 0px; padding: 0px; border: 0px; font-style: inherit; font-variant: inherit; font-weight: inherit !important; font-stretch: inherit; font-size: inherit !important; line-height: inherit !important; font-family: inherit; vertical-align: baseline; height: inherit; color: rgb(0, 45, 122) !important;">std</span> 
      <span style="margin: 0px; padding: 0px; border: 0px; font-style: inherit; font-variant: inherit; font-weight: inherit !important; font-stretch: inherit; font-size: inherit !important; line-height: inherit !important; font-family: inherit; vertical-align: baseline; height: inherit; color: rgb(0, 111, 224) !important;">::</span> 
      <span style="margin: 0px; padding: 0px; border: 0px; font-style: inherit; font-variant: inherit; font-stretch: inherit; font-family: inherit; vertical-align: baseline; height: inherit; font-weight: bold !important; font-size: inherit !important; line-height: inherit !important;">cout</span> 
      <span style="margin: 0px; padding: 0px; border: 0px; font-style: inherit; font-variant: inherit; font-weight: inherit !important; font-stretch: inherit; font-size: inherit !important; line-height: inherit !important; font-family: inherit; vertical-align: baseline; height: inherit; color: rgb(0, 111, 224) !important;"> </span> 
      <span style="margin: 0px; padding: 0px; border: 0px; font-style: inherit; font-variant: inherit; font-weight: inherit !important; font-stretch: inherit; font-size: inherit !important; line-height: inherit !important; font-family: inherit; vertical-align: baseline; height: inherit; color: rgb(0, 111, 224) !important;">&lt;&lt;</span> 
      <span style="margin: 0px; padding: 0px; border: 0px; font-style: inherit; font-variant: inherit; font-weight: inherit !important; font-stretch: inherit; font-size: inherit !important; line-height: inherit !important; font-family: inherit; vertical-align: baseline; height: inherit; color: rgb(0, 111, 224) !important;"> </span> 
      <span style="margin: 0px; padding: 0px; border: 0px; font-style: inherit; font-variant: inherit; font-weight: inherit !important; font-stretch: inherit; font-size: inherit !important; line-height: inherit !important; font-family: inherit; vertical-align: baseline; height: inherit; color: rgb(51, 51, 51) !important;">[</span> 
      <span style="margin: 0px; padding: 0px; border: 0px; font-style: inherit; font-variant: inherit; font-weight: inherit !important; font-stretch: inherit; font-size: inherit !important; line-height: inherit !important; font-family: inherit; vertical-align: baseline; height: inherit; color: rgb(0, 111, 224) !important;">=</span> 
      <span style="margin: 0px; padding: 0px; border: 0px; font-style: inherit; font-variant: inherit; font-weight: inherit !important; font-stretch: inherit; font-size: inherit !important; line-height: inherit !important; font-family: inherit; vertical-align: baseline; height: inherit; color: rgb(51, 51, 51) !important;">]</span> 
      <span style="margin: 0px; padding: 0px; border: 0px; font-style: inherit; font-variant: inherit; font-weight: inherit !important; font-stretch: inherit; font-size: inherit !important; line-height: inherit !important; font-family: inherit; vertical-align: baseline; height: inherit; color: rgb(51, 51, 51) !important;">(</span> 
      <span style="margin: 0px; padding: 0px; border: 0px; font-style: inherit; font-variant: inherit; font-weight: bold !important; font-stretch: inherit; font-size: inherit !important; line-height: inherit !important; font-family: inherit; vertical-align: baseline; height: inherit; color: rgb(128, 0, 128) !important;">float</span> 
      <span style="margin: 0px; padding: 0px; border: 0px; font-style: inherit; font-variant: inherit; font-weight: inherit !important; font-stretch: inherit; font-size: inherit !important; line-height: inherit !important; font-family: inherit; vertical-align: baseline; height: inherit; color: rgb(0, 111, 224) !important;"> </span> 
      <span style="margin: 0px; padding: 0px; border: 0px; font-style: inherit; font-variant: inherit; font-weight: inherit !important; font-stretch: inherit; font-size: inherit !important; line-height: inherit !important; font-family: inherit; vertical-align: baseline; height: inherit; color: rgb(0, 45, 122) !important;">f</span> 
      <span style="margin: 0px; padding: 0px; border: 0px; font-style: inherit; font-variant: inherit; font-weight: inherit !important; font-stretch: inherit; font-size: inherit !important; line-height: inherit !important; font-family: inherit; vertical-align: baseline; height: inherit; color: rgb(51, 51, 51) !important;">)</span> 
      <span style="margin: 0px; padding: 0px; border: 0px; font-style: inherit; font-variant: inherit; font-weight: inherit !important; font-stretch: inherit; font-size: inherit !important; line-height: inherit !important; font-family: inherit; vertical-align: baseline; height: inherit; color: rgb(0, 111, 224) !important;"> </span> 
      <span style="margin: 0px; padding: 0px; border: 0px; font-style: inherit; font-variant: inherit; font-weight: inherit !important; font-stretch: inherit; font-size: inherit !important; line-height: inherit !important; font-family: inherit; vertical-align: baseline; height: inherit; color: rgb(128, 0, 128) !important;">mutable</span> 
      <span style="margin: 0px; padding: 0px; border: 0px; font-style: inherit; font-variant: inherit; font-weight: inherit !important; font-stretch: inherit; font-size: inherit !important; line-height: inherit !important; font-family: inherit; vertical-align: baseline; height: inherit; color: rgb(0, 111, 224) !important;"> </span> 
      <span style="margin: 0px; padding: 0px; border: 0px; font-style: inherit; font-variant: inherit; font-weight: inherit !important; font-stretch: inherit; font-size: inherit !important; line-height: inherit !important; font-family: inherit; vertical-align: baseline; height: inherit; color: rgb(51, 51, 51) !important;">{ </span> 
      <span style="margin: 0px; padding: 0px; border: 0px; font-style: inherit; font-variant: inherit; font-weight: inherit !important; font-stretch: inherit; font-size: inherit !important; line-height: inherit !important; font-family: inherit; vertical-align: baseline; height: inherit; color: rgb(0, 111, 224) !important;"> </span> 
      <span style="margin: 0px; padding: 0px; border: 0px; font-style: inherit; font-variant: inherit; font-stretch: inherit; font-family: inherit; vertical-align: baseline; height: inherit; font-weight: bold !important; font-size: inherit !important; line-height: inherit !important;">return</span> 
      <span style="margin: 0px; padding: 0px; border: 0px; font-style: inherit; font-variant: inherit; font-weight: inherit !important; font-stretch: inherit; font-size: inherit !important; line-height: inherit !important; font-family: inherit; vertical-align: baseline; height: inherit; color: rgb(0, 111, 224) !important;"> </span> 
      <span style="margin: 0px; padding: 0px; border: 0px; font-style: inherit; font-variant: inherit; font-weight: inherit !important; font-stretch: inherit; font-size: inherit !important; line-height: inherit !important; font-family: inherit; vertical-align: baseline; height: inherit; color: rgb(0, 45, 122) !important;">f0</span> 
      <span style="margin: 0px; padding: 0px; border: 0px; font-style: inherit; font-variant: inherit; font-weight: inherit !important; font-stretch: inherit; font-size: inherit !important; line-height: inherit !important; font-family: inherit; vertical-align: baseline; height: inherit; color: rgb(0, 111, 224) !important;"> </span> 
      <span style="margin: 0px; padding: 0px; border: 0px; font-style: inherit; font-variant: inherit; font-weight: inherit !important; font-stretch: inherit; font-size: inherit !important; line-height: inherit !important; font-family: inherit; vertical-align: baseline; height: inherit; color: rgb(0, 111, 224) !important;">+=</span> 
      <span style="margin: 0px; padding: 0px; border: 0px; font-style: inherit; font-variant: inherit; font-weight: inherit !important; font-stretch: inherit; font-size: inherit !important; line-height: inherit !important; font-family: inherit; vertical-align: baseline; height: inherit; color: rgb(0, 111, 224) !important;"> </span> 
      <span style="margin: 0px; padding: 0px; border: 0px; font-style: inherit; font-variant: inherit; font-weight: inherit !important; font-stretch: inherit; font-size: inherit !important; line-height: inherit !important; font-family: inherit; vertical-align: baseline; height: inherit; color: rgb(0, 45, 122) !important;">std</span> 
      <span style="margin: 0px; padding: 0px; border: 0px; font-style: inherit; font-variant: inherit; font-weight: inherit !important; font-stretch: inherit; font-size: inherit !important; line-height: inherit !important; font-family: inherit; vertical-align: baseline; height: inherit; color: rgb(0, 111, 224) !important;">::</span> 
      <span style="margin: 0px; padding: 0px; border: 0px; font-style: inherit; font-variant: inherit; font-weight: inherit !important; font-stretch: inherit; font-size: inherit !important; line-height: inherit !important; font-family: inherit; vertical-align: baseline; height: inherit; color: teal !important;">abs</span> 
      <span style="margin: 0px; padding: 0px; border: 0px; font-style: inherit; font-variant: inherit; font-weight: inherit !important; font-stretch: inherit; font-size: inherit !important; line-height: inherit !important; font-family: inherit; vertical-align: baseline; height: inherit; color: rgb(51, 51, 51) !important;">(</span> 
      <span style="margin: 0px; padding: 0px; border: 0px; font-style: inherit; font-variant: inherit; font-weight: inherit !important; font-stretch: inherit; font-size: inherit !important; line-height: inherit !important; font-family: inherit; vertical-align: baseline; height: inherit; color: rgb(0, 45, 122) !important;">f</span> 
      <span style="margin: 0px; padding: 0px; border: 0px; font-style: inherit; font-variant: inherit; font-weight: inherit !important; font-stretch: inherit; font-size: inherit !important; line-height: inherit !important; font-family: inherit; vertical-align: baseline; height: inherit; color: rgb(51, 51, 51) !important;">)</span> 
      <span style="margin: 0px; padding: 0px; border: 0px; font-style: inherit; font-variant: inherit; font-weight: inherit !important; font-stretch: inherit; font-size: inherit !important; line-height: inherit !important; font-family: inherit; vertical-align: baseline; height: inherit; color: rgb(51, 51, 51) !important;">;</span> 
      <span style="margin: 0px; padding: 0px; border: 0px; font-style: inherit; font-variant: inherit; font-weight: inherit !important; font-stretch: inherit; font-size: inherit !important; line-height: inherit !important; font-family: inherit; vertical-align: baseline; height: inherit; color: rgb(0, 111, 224) !important;"> </span> 
      <span style="margin: 0px; padding: 0px; border: 0px; font-style: inherit; font-variant: inherit; font-weight: inherit !important; font-stretch: inherit; font-size: inherit !important; line-height: inherit !important; font-family: inherit; vertical-align: baseline; height: inherit; color: rgb(51, 51, 51) !important;">}</span> 
      <span style="margin: 0px; padding: 0px; border: 0px; font-style: inherit; font-variant: inherit; font-weight: inherit !important; font-stretch: inherit; font-size: inherit !important; line-height: inherit !important; font-family: inherit; vertical-align: baseline; height: inherit; color: rgb(0, 111, 224) !important;"> </span> 
      <span style="margin: 0px; padding: 0px; border: 0px; font-style: inherit; font-variant: inherit; font-weight: inherit !important; font-stretch: inherit; font-size: inherit !important; line-height: inherit !important; font-family: inherit; vertical-align: baseline; height: inherit; color: rgb(51, 51, 51) !important;">(</span> 
      <span style="margin: 0px; padding: 0px; border: 0px; font-style: inherit; font-variant: inherit; font-weight: inherit !important; font-stretch: inherit; font-size: inherit !important; line-height: inherit !important; font-family: inherit; vertical-align: baseline; height: inherit; color: rgb(0, 111, 224) !important;">-</span> 
      <span style="margin: 0px; padding: 0px; border: 0px; font-style: inherit; font-variant: inherit; font-weight: inherit !important; font-stretch: inherit; font-size: inherit !important; line-height: inherit !important; font-family: inherit; vertical-align: baseline; height: inherit; color: rgb(0, 153, 153) !important;">3.5</span> 
      <span style="margin: 0px; padding: 0px; border: 0px; font-style: inherit; font-variant: inherit; font-weight: inherit !important; font-stretch: inherit; font-size: inherit !important; line-height: inherit !important; font-family: inherit; vertical-align: baseline; height: inherit; color: rgb(51, 51, 51) !important;">)</span> 
      <span style="margin: 0px; padding: 0px; border: 0px; font-style: inherit; font-variant: inherit; font-weight: inherit !important; font-stretch: inherit; font-size: inherit !important; line-height: inherit !important; font-family: inherit; vertical-align: baseline; height: inherit; color: rgb(51, 51, 51) !important;">;</span> 
     </div> 
     <div style="margin: 0px; padding: 0px 5px; border: 0px; font-style: inherit; font-variant: inherit; font-stretch: inherit; font-family: inherit; vertical-align: baseline; background: 0px center; height: inherit; font-weight: inherit !important; font-size: inherit !important; line-height: inherit !important;"> 
      <span style="margin: 0px; padding: 0px; border: 0px; font-style: inherit; font-variant: inherit; font-weight: inherit !important; font-stretch: inherit; font-size: inherit !important; line-height: inherit !important; font-family: inherit; vertical-align: baseline; height: inherit; color: rgb(0, 45, 122) !important;">std</span> 
      <span style="margin: 0px; padding: 0px; border: 0px; font-style: inherit; font-variant: inherit; font-weight: inherit !important; font-stretch: inherit; font-size: inherit !important; line-height: inherit !important; font-family: inherit; vertical-align: baseline; height: inherit; color: rgb(0, 111, 224) !important;">::</span> 
      <span style="margin: 0px; padding: 0px; border: 0px; font-style: inherit; font-variant: inherit; font-stretch: inherit; font-family: inherit; vertical-align: baseline; height: inherit; font-weight: bold !important; font-size: inherit !important; line-height: inherit !important;">cout</span> 
      <span style="margin: 0px; padding: 0px; border: 0px; font-style: inherit; font-variant: inherit; font-weight: inherit !important; font-stretch: inherit; font-size: inherit !important; line-height: inherit !important; font-family: inherit; vertical-align: baseline; height: inherit; color: rgb(0, 111, 224) !important;"> </span> 
      <span style="margin: 0px; padding: 0px; border: 0px; font-style: inherit; font-variant: inherit; font-weight: inherit !important; font-stretch: inherit; font-size: inherit !important; line-height: inherit !important; font-family: inherit; vertical-align: baseline; height: inherit; color: rgb(0, 111, 224) !important;">&lt;&lt;</span> 
      <span style="margin: 0px; padding: 0px; border: 0px; font-style: inherit; font-variant: inherit; font-weight: inherit !important; font-stretch: inherit; font-size: inherit !important; line-height: inherit !important; font-family: inherit; vertical-align: baseline; height: inherit; color: rgb(0, 111, 224) !important;"> </span> 
      <span style="margin: 0px; padding: 0px; border: 0px; font-style: inherit; font-variant: inherit; font-weight: inherit !important; font-stretch: inherit; font-size: inherit !important; line-height: inherit !important; font-family: inherit; vertical-align: baseline; height: inherit; color: rgb(221, 17, 68) !important;">'\n'</span> 
      <span style="margin: 0px; padding: 0px; border: 0px; font-style: inherit; font-variant: inherit; font-weight: inherit !important; font-stretch: inherit; font-size: inherit !important; line-height: inherit !important; font-family: inherit; vertical-align: baseline; height: inherit; color: rgb(0, 111, 224) !important;"> </span> 
      <span style="margin: 0px; padding: 0px; border: 0px; font-style: inherit; font-variant: inherit; font-weight: inherit !important; font-stretch: inherit; font-size: inherit !important; line-height: inherit !important; font-family: inherit; vertical-align: baseline; height: inherit; color: rgb(0, 111, 224) !important;">&lt;&lt;</span> 
      <span style="margin: 0px; padding: 0px; border: 0px; font-style: inherit; font-variant: inherit; font-weight: inherit !important; font-stretch: inherit; font-size: inherit !important; line-height: inherit !important; font-family: inherit; vertical-align: baseline; height: inherit; color: rgb(0, 111, 224) !important;"> </span> 
      <span style="margin: 0px; padding: 0px; border: 0px; font-style: inherit; font-variant: inherit; font-weight: inherit !important; font-stretch: inherit; font-size: inherit !important; line-height: inherit !important; font-family: inherit; vertical-align: baseline; height: inherit; color: rgb(0, 45, 122) !important;">f0</span> 
      <span style="margin: 0px; padding: 0px; border: 0px; font-style: inherit; font-variant: inherit; font-weight: inherit !important; font-stretch: inherit; font-size: inherit !important; line-height: inherit !important; font-family: inherit; vertical-align: baseline; height: inherit; color: rgb(0, 111, 224) !important;"> </span> 
      <span style="margin: 0px; padding: 0px; border: 0px; font-style: inherit; font-variant: inherit; font-weight: inherit !important; font-stretch: inherit; font-size: inherit !important; line-height: inherit !important; font-family: inherit; vertical-align: baseline; height: inherit; color: rgb(0, 111, 224) !important;">&lt;&lt;</span> 
      <span style="margin: 0px; padding: 0px; border: 0px; font-style: inherit; font-variant: inherit; font-weight: inherit !important; font-stretch: inherit; font-size: inherit !important; line-height: inherit !important; font-family: inherit; vertical-align: baseline; height: inherit; color: rgb(0, 111, 224) !important;"> </span> 
      <span style="margin: 0px; padding: 0px; border: 0px; font-style: inherit; font-variant: inherit; font-weight: inherit !important; font-stretch: inherit; font-size: inherit !important; line-height: inherit !important; font-family: inherit; vertical-align: baseline; height: inherit; color: rgb(221, 17, 68) !important;">'\n'</span> 
      <span style="margin: 0px; padding: 0px; border: 0px; font-style: inherit; font-variant: inherit; font-weight: inherit !important; font-stretch: inherit; font-size: inherit !important; line-height: inherit !important; font-family: inherit; vertical-align: baseline; height: inherit; color: rgb(51, 51, 51) !important;">;</span> 
     </div> 
    </div></td> 
  </tr> 
 </tbody> 
</table>

这个例子很有趣。首先，`[=]`意味着，lambda 表达式以传值的形式捕获外部变量。C++ 11 标准说，如果以传值的形式捕获外部变量，那么，lambda 体不允许修改外部变量，对 f0 的任何修改都会引发编译错误。但是，注意，我们在 lambda 表达式前声明了`mutable`关键字，这就允许了 lambda 表达式体修改 f0 的值。因此，我们的例子本应报错，但是由于有 mutable 关键字，则不会报错。那么，你会觉得输出值是什么呢？答案是，4.5 和 1.0。为什么 f0 还是 1.0？因为我们是传值的，虽然在 lambda 表达式中对 f0 有了修改，但由于是传值的，外部的 f0 依然不会被修改。

上面的例子是，所有的变量要么传值，要么传引用。那么，是不是有混合机制呢？当然也有！比如下面的例子：

C++

<table style="margin-left:0px; font-style:inherit; font-variant:inherit; font-weight:inherit; font-size:12px; line-height:inherit; vertical-align:baseline; margin-top:0px!important; margin-right:0px!important; margin-bottom:0px!important; padding:0px!important; border:none!important; border-collapse:collapse!important; border-spacing:0px!important; width:auto!important; background:none!important; table-layout:auto!important"> 
 <tbody style="margin:0px; padding:0px; border:0px; font-style:inherit; font-variant:inherit; font-weight:inherit; font-size:undefined; line-height:inherit; vertical-align:baseline"> 
  <tr style="font-style:inherit; font-variant:inherit; font-weight:inherit; font-size:undefined; line-height:inherit; background:0px center; margin:0px!important; padding:0px!important; border:none!important; vertical-align:top!important"> 
   <td style="border:0px; font-style:inherit; font-variant:inherit; font-weight:inherit; font-size:undefined; line-height:inherit; margin:0px!important; padding:0px!important; font-family:Consolas,ConsolasRegular,&quot;Courier New&quot;,monospace!important; vertical-align:top!important; background-color:rgb(238,238,238)!important"> 
    <div style="margin:0px; padding-right:0px; padding-left:0px; border:0px; font-style:inherit; font-variant:inherit; font-weight:inherit; vertical-align:baseline; background:0px center; white-space:nowrap; padding-top:5px!important; padding-bottom:3px!important; line-height:15px!important"> 
     <div style="margin:0px; padding:0px 5px; border-top:0px; border-right:1px solid rgb(222,222,222)!important; border-bottom:0px; border-left:0px; font-style:inherit; font-variant:inherit; font-weight:inherit!important; font-size:inherit!important; line-height:inherit!important; font-family:inherit; vertical-align:baseline; background:0px center; text-align:right!important; height:inherit; min-width:1.2em!important; color:rgb(170,170,170)!important">
       1 
     </div> 
     <div style="margin:0px; padding:0px 5px; border-top:0px; border-right:1px solid rgb(222,222,222)!important; border-bottom:0px; border-left:0px; font-style:inherit; font-variant:inherit; font-weight:inherit!important; font-size:inherit!important; line-height:inherit!important; font-family:inherit; vertical-align:baseline; background:0px center; text-align:right!important; height:inherit; min-width:1.2em!important; color:rgb(170,170,170)!important">
       2 
     </div> 
     <div style="margin:0px; padding:0px 5px; border-top:0px; border-right:1px solid rgb(222,222,222)!important; border-bottom:0px; border-left:0px; font-style:inherit; font-variant:inherit; font-weight:inherit!important; font-size:inherit!important; line-height:inherit!important; font-family:inherit; vertical-align:baseline; background:0px center; text-align:right!important; height:inherit; min-width:1.2em!important; color:rgb(170,170,170)!important">
       3 
     </div> 
     <div style="margin:0px; padding:0px 5px; border-top:0px; border-right:1px solid rgb(222,222,222)!important; border-bottom:0px; border-left:0px; font-style:inherit; font-variant:inherit; font-weight:inherit!important; font-size:inherit!important; line-height:inherit!important; font-family:inherit; vertical-align:baseline; background:0px center; text-align:right!important; height:inherit; min-width:1.2em!important; color:rgb(170,170,170)!important">
       4 
     </div> 
    </div> </td> 
   <td style="border:0px; font-style:inherit; font-variant:inherit; font-weight:inherit; font-size:undefined; line-height:inherit; background:0px center; width:582.4px; margin:0px!important; padding:0px!important; font-family:Consolas,ConsolasRegular,&quot;Courier New&quot;,monospace!important; vertical-align:top!important"> 
    <div style="margin:0px; padding-right:0px; padding-left:0px; font-style:inherit; font-variant:inherit; font-weight:inherit; vertical-align:baseline; white-space:pre; overflow:visible; padding-top:5px!important; padding-bottom:3px!important; border:none!important; line-height:15px!important; background:none!important"> 
     <div style="margin:0px; padding:0px 5px; border:0px; font-style:inherit; font-variant:inherit; font-family:inherit; vertical-align:baseline; background:0px center; height:inherit; font-weight:inherit!important; font-size:inherit!important; line-height:inherit!important"> 
      <span style="margin:0px; padding:0px; border:0px; font-style:inherit; font-variant:inherit; font-weight:bold!important; font-size:inherit!important; line-height:inherit!important; font-family:inherit; vertical-align:baseline; height:inherit; color:rgb(128,0,128)!important">float</span> 
      <span style="margin:0px; padding:0px; border:0px; font-style:inherit; font-variant:inherit; font-weight:inherit!important; font-size:inherit!important; line-height:inherit!important; font-family:inherit; vertical-align:baseline; height:inherit; color:rgb(0,111,224)!important"> </span> 
      <span style="margin:0px; padding:0px; border:0px; font-style:inherit; font-variant:inherit; font-weight:inherit!important; font-size:inherit!important; line-height:inherit!important; font-family:inherit; vertical-align:baseline; height:inherit; color:rgb(0,45,122)!important">f0</span> 
      <span style="margin:0px; padding:0px; border:0px; font-style:inherit; font-variant:inherit; font-weight:inherit!important; font-size:inherit!important; line-height:inherit!important; font-family:inherit; vertical-align:baseline; height:inherit; color:rgb(0,111,224)!important"> </span> 
      <span style="margin:0px; padding:0px; border:0px; font-style:inherit; font-variant:inherit; font-weight:inherit!important; font-size:inherit!important; line-height:inherit!important; font-family:inherit; vertical-align:baseline; height:inherit; color:rgb(0,111,224)!important">=</span> 
      <span style="margin:0px; padding:0px; border:0px; font-style:inherit; font-variant:inherit; font-weight:inherit!important; font-size:inherit!important; line-height:inherit!important; font-family:inherit; vertical-align:baseline; height:inherit; color:rgb(0,111,224)!important"> </span> 
      <span style="margin:0px; padding:0px; border:0px; font-style:inherit; font-variant:inherit; font-weight:inherit!important; font-size:inherit!important; line-height:inherit!important; font-family:inherit; vertical-align:baseline; height:inherit; color:rgb(0,153,153)!important">1.0f</span> 
      <span style="margin:0px; padding:0px; border:0px; font-style:inherit; font-variant:inherit; font-weight:inherit!important; font-size:inherit!important; line-height:inherit!important; font-family:inherit; vertical-align:baseline; height:inherit; color:rgb(51,51,51)!important">;</span> 
     </div> 
     <div style="margin:0px; padding:0px 5px; border:0px; font-style:inherit; font-variant:inherit; font-family:inherit; vertical-align:baseline; background:0px center; height:inherit; font-weight:inherit!important; font-size:inherit!important; line-height:inherit!important"> 
      <span style="margin:0px; padding:0px; border:0px; font-style:inherit; font-variant:inherit; font-weight:bold!important; font-size:inherit!important; line-height:inherit!important; font-family:inherit; vertical-align:baseline; height:inherit; color:rgb(128,0,128)!important">float</span> 
      <span style="margin:0px; padding:0px; border:0px; font-style:inherit; font-variant:inherit; font-weight:inherit!important; font-size:inherit!important; line-height:inherit!important; font-family:inherit; vertical-align:baseline; height:inherit; color:rgb(0,111,224)!important"> </span> 
      <span style="margin:0px; padding:0px; border:0px; font-style:inherit; font-variant:inherit; font-weight:inherit!important; font-size:inherit!important; line-height:inherit!important; font-family:inherit; vertical-align:baseline; height:inherit; color:rgb(0,45,122)!important">f1</span> 
      <span style="margin:0px; padding:0px; border:0px; font-style:inherit; font-variant:inherit; font-weight:inherit!important; font-size:inherit!important; line-height:inherit!important; font-family:inherit; vertical-align:baseline; height:inherit; color:rgb(0,111,224)!important"> </span> 
      <span style="margin:0px; padding:0px; border:0px; font-style:inherit; font-variant:inherit; font-weight:inherit!important; font-size:inherit!important; line-height:inherit!important; font-family:inherit; vertical-align:baseline; height:inherit; color:rgb(0,111,224)!important">=</span> 
      <span style="margin:0px; padding:0px; border:0px; font-style:inherit; font-variant:inherit; font-weight:inherit!important; font-size:inherit!important; line-height:inherit!important; font-family:inherit; vertical-align:baseline; height:inherit; color:rgb(0,111,224)!important"> </span> 
      <span style="margin:0px; padding:0px; border:0px; font-style:inherit; font-variant:inherit; font-weight:inherit!important; font-size:inherit!important; line-height:inherit!important; font-family:inherit; vertical-align:baseline; height:inherit; color:rgb(0,153,153)!important">10.0f</span> 
      <span style="margin:0px; padding:0px; border:0px; font-style:inherit; font-variant:inherit; font-weight:inherit!important; font-size:inherit!important; line-height:inherit!important; font-family:inherit; vertical-align:baseline; height:inherit; color:rgb(51,51,51)!important">;</span> 
     </div> 
     <div style="margin:0px; padding:0px 5px; border:0px; font-style:inherit; font-variant:inherit; font-family:inherit; vertical-align:baseline; background:0px center; height:inherit; font-weight:inherit!important; font-size:inherit!important; line-height:inherit!important"> 
      <span style="margin:0px; padding:0px; border:0px; font-style:inherit; font-variant:inherit; font-weight:inherit!important; font-size:inherit!important; line-height:inherit!important; font-family:inherit; vertical-align:baseline; height:inherit; color:rgb(0,45,122)!important">std</span> 
      <span style="margin:0px; padding:0px; border:0px; font-style:inherit; font-variant:inherit; font-weight:inherit!important; font-size:inherit!important; line-height:inherit!important; font-family:inherit; vertical-align:baseline; height:inherit; color:rgb(0,111,224)!important">::</span> 
      <span style="margin:0px; padding:0px; border:0px; font-style:inherit; font-variant:inherit; font-family:inherit; vertical-align:baseline; height:inherit; font-weight:bold!important; font-size:inherit!important; line-height:inherit!important">cout</span> 
      <span style="margin:0px; padding:0px; border:0px; font-style:inherit; font-variant:inherit; font-weight:inherit!important; font-size:inherit!important; line-height:inherit!important; font-family:inherit; vertical-align:baseline; height:inherit; color:rgb(0,111,224)!important"> </span> 
      <span style="margin:0px; padding:0px; border:0px; font-style:inherit; font-variant:inherit; font-weight:inherit!important; font-size:inherit!important; line-height:inherit!important; font-family:inherit; vertical-align:baseline; height:inherit; color:rgb(0,111,224)!important">&lt;&lt;</span> 
      <span style="margin:0px; padding:0px; border:0px; font-style:inherit; font-variant:inherit; font-weight:inherit!important; font-size:inherit!important; line-height:inherit!important; font-family:inherit; vertical-align:baseline; height:inherit; color:rgb(0,111,224)!important"> </span> 
      <span style="margin:0px; padding:0px; border:0px; font-style:inherit; font-variant:inherit; font-weight:inherit!important; font-size:inherit!important; line-height:inherit!important; font-family:inherit; vertical-align:baseline; height:inherit; color:rgb(51,51,51)!important">[</span> 
      <span style="margin:0px; padding:0px; border:0px; font-style:inherit; font-variant:inherit; font-weight:inherit!important; font-size:inherit!important; line-height:inherit!important; font-family:inherit; vertical-align:baseline; height:inherit; color:rgb(0,111,224)!important">=</span> 
      <span style="margin:0px; padding:0px; border:0px; font-style:inherit; font-variant:inherit; font-weight:inherit!important; font-size:inherit!important; line-height:inherit!important; font-family:inherit; vertical-align:baseline; height:inherit; color:rgb(51,51,51)!important">,</span> 
      <span style="margin:0px; padding:0px; border:0px; font-style:inherit; font-variant:inherit; font-weight:inherit!important; font-size:inherit!important; line-height:inherit!important; font-family:inherit; vertical-align:baseline; height:inherit; color:rgb(0,111,224)!important"> </span> 
      <span style="margin:0px; padding:0px; border:0px; font-style:inherit; font-variant:inherit; font-weight:inherit!important; font-size:inherit!important; line-height:inherit!important; font-family:inherit; vertical-align:baseline; height:inherit; color:rgb(0,45,122)!important">&amp;f0</span> 
      <span style="margin:0px; padding:0px; border:0px; font-style:inherit; font-variant:inherit; font-weight:inherit!important; font-size:inherit!important; line-height:inherit!important; font-family:inherit; vertical-align:baseline; height:inherit; color:rgb(51,51,51)!important">]</span> 
      <span style="margin:0px; padding:0px; border:0px; font-style:inherit; font-variant:inherit; font-weight:inherit!important; font-size:inherit!important; line-height:inherit!important; font-family:inherit; vertical-align:baseline; height:inherit; color:rgb(51,51,51)!important">(</span> 
      <span style="margin:0px; padding:0px; border:0px; font-style:inherit; font-variant:inherit; font-weight:bold!important; font-size:inherit!important; line-height:inherit!important; font-family:inherit; vertical-align:baseline; height:inherit; color:rgb(128,0,128)!important">float</span> 
      <span style="margin:0px; padding:0px; border:0px; font-style:inherit; font-variant:inherit; font-weight:inherit!important; font-size:inherit!important; line-height:inherit!important; font-family:inherit; vertical-align:baseline; height:inherit; color:rgb(0,111,224)!important"> </span> 
      <span style="margin:0px; padding:0px; border:0px; font-style:inherit; font-variant:inherit; font-weight:inherit!important; font-size:inherit!important; line-height:inherit!important; font-family:inherit; vertical-align:baseline; height:inherit; color:rgb(0,45,122)!important">a</span> 
      <span style="margin:0px; padding:0px; border:0px; font-style:inherit; font-variant:inherit; font-weight:inherit!important; font-size:inherit!important; line-height:inherit!important; font-family:inherit; vertical-align:baseline; height:inherit; color:rgb(51,51,51)!important">)</span> 
      <span style="margin:0px; padding:0px; border:0px; font-style:inherit; font-variant:inherit; font-weight:inherit!important; font-size:inherit!important; line-height:inherit!important; font-family:inherit; vertical-align:baseline; height:inherit; color:rgb(0,111,224)!important"> </span> 
      <span style="margin:0px; padding:0px; border:0px; font-style:inherit; font-variant:inherit; font-weight:inherit!important; font-size:inherit!important; line-height:inherit!important; font-family:inherit; vertical-align:baseline; height:inherit; color:rgb(51,51,51)!important">{ </span> 
      <span style="margin:0px; padding:0px; border:0px; font-style:inherit; font-variant:inherit; font-weight:inherit!important; font-size:inherit!important; line-height:inherit!important; font-family:inherit; vertical-align:baseline; height:inherit; color:rgb(0,111,224)!important"> </span> 
      <span style="margin:0px; padding:0px; border:0px; font-style:inherit; font-variant:inherit; font-family:inherit; vertical-align:baseline; height:inherit; font-weight:bold!important; font-size:inherit!important; line-height:inherit!important">return</span> 
      <span style="margin:0px; padding:0px; border:0px; font-style:inherit; font-variant:inherit; font-weight:inherit!important; font-size:inherit!important; line-height:inherit!important; font-family:inherit; vertical-align:baseline; height:inherit; color:rgb(0,111,224)!important"> </span> 
      <span style="margin:0px; padding:0px; border:0px; font-style:inherit; font-variant:inherit; font-weight:inherit!important; font-size:inherit!important; line-height:inherit!important; font-family:inherit; vertical-align:baseline; height:inherit; color:rgb(0,45,122)!important">f0</span> 
      <span style="margin:0px; padding:0px; border:0px; font-style:inherit; font-variant:inherit; font-weight:inherit!important; font-size:inherit!important; line-height:inherit!important; font-family:inherit; vertical-align:baseline; height:inherit; color:rgb(0,111,224)!important"> </span> 
      <span style="margin:0px; padding:0px; border:0px; font-style:inherit; font-variant:inherit; font-weight:inherit!important; font-size:inherit!important; line-height:inherit!important; font-family:inherit; vertical-align:baseline; height:inherit; color:rgb(0,111,224)!important">+=</span> 
      <span style="margin:0px; padding:0px; border:0px; font-style:inherit; font-variant:inherit; font-weight:inherit!important; font-size:inherit!important; line-height:inherit!important; font-family:inherit; vertical-align:baseline; height:inherit; color:rgb(0,111,224)!important"> </span> 
      <span style="margin:0px; padding:0px; border:0px; font-style:inherit; font-variant:inherit; font-weight:inherit!important; font-size:inherit!important; line-height:inherit!important; font-family:inherit; vertical-align:baseline; height:inherit; color:rgb(0,45,122)!important">f1</span> 
      <span style="margin:0px; padding:0px; border:0px; font-style:inherit; font-variant:inherit; font-weight:inherit!important; font-size:inherit!important; line-height:inherit!important; font-family:inherit; vertical-align:baseline; height:inherit; color:rgb(0,111,224)!important"> </span> 
      <span style="margin:0px; padding:0px; border:0px; font-style:inherit; font-variant:inherit; font-weight:inherit!important; font-size:inherit!important; line-height:inherit!important; font-family:inherit; vertical-align:baseline; height:inherit; color:rgb(0,111,224)!important">+</span> 
      <span style="margin:0px; padding:0px; border:0px; font-style:inherit; font-variant:inherit; font-weight:inherit!important; font-size:inherit!important; line-height:inherit!important; font-family:inherit; vertical-align:baseline; height:inherit; color:rgb(0,111,224)!important"> </span> 
      <span style="margin:0px; padding:0px; border:0px; font-style:inherit; font-variant:inherit; font-weight:inherit!important; font-size:inherit!important; line-height:inherit!important; font-family:inherit; vertical-align:baseline; height:inherit; color:rgb(0,45,122)!important">std</span> 
      <span style="margin:0px; padding:0px; border:0px; font-style:inherit; font-variant:inherit; font-weight:inherit!important; font-size:inherit!important; line-height:inherit!important; font-family:inherit; vertical-align:baseline; height:inherit; color:rgb(0,111,224)!important">::</span> 
      <span style="margin:0px; padding:0px; border:0px; font-style:inherit; font-variant:inherit; font-weight:inherit!important; font-size:inherit!important; line-height:inherit!important; font-family:inherit; vertical-align:baseline; height:inherit; color:teal!important">abs</span> 
      <span style="margin:0px; padding:0px; border:0px; font-style:inherit; font-variant:inherit; font-weight:inherit!important; font-size:inherit!important; line-height:inherit!important; font-family:inherit; vertical-align:baseline; height:inherit; color:rgb(51,51,51)!important">(</span> 
      <span style="margin:0px; padding:0px; border:0px; font-style:inherit; font-variant:inherit; font-weight:inherit!important; font-size:inherit!important; line-height:inherit!important; font-family:inherit; vertical-align:baseline; height:inherit; color:rgb(0,45,122)!important">a</span> 
      <span style="margin:0px; padding:0px; border:0px; font-style:inherit; font-variant:inherit; font-weight:inherit!important; font-size:inherit!important; line-height:inherit!important; font-family:inherit; vertical-align:baseline; height:inherit; color:rgb(51,51,51)!important">)</span> 
      <span style="margin:0px; padding:0px; border:0px; font-style:inherit; font-variant:inherit; font-weight:inherit!important; font-size:inherit!important; line-height:inherit!important; font-family:inherit; vertical-align:baseline; height:inherit; color:rgb(51,51,51)!important">;</span> 
      <span style="margin:0px; padding:0px; border:0px; font-style:inherit; font-variant:inherit; font-weight:inherit!important; font-size:inherit!important; line-height:inherit!important; font-family:inherit; vertical-align:baseline; height:inherit; color:rgb(0,111,224)!important"> </span> 
      <span style="margin:0px; padding:0px; border:0px; font-style:inherit; font-variant:inherit; font-weight:inherit!important; font-size:inherit!important; line-height:inherit!important; font-family:inherit; vertical-align:baseline; height:inherit; color:rgb(51,51,51)!important">}</span> 
      <span style="margin:0px; padding:0px; border:0px; font-style:inherit; font-variant:inherit; font-weight:inherit!important; font-size:inherit!important; line-height:inherit!important; font-family:inherit; vertical-align:baseline; height:inherit; color:rgb(0,111,224)!important"> </span> 
      <span style="margin:0px; padding:0px; border:0px; font-style:inherit; font-variant:inherit; font-weight:inherit!important; font-size:inherit!important; line-height:inherit!important; font-family:inherit; vertical-align:baseline; height:inherit; color:rgb(51,51,51)!important">(</span> 
      <span style="margin:0px; padding:0px; border:0px; font-style:inherit; font-variant:inherit; font-weight:inherit!important; font-size:inherit!important; line-height:inherit!important; font-family:inherit; vertical-align:baseline; height:inherit; color:rgb(0,111,224)!important">-</span> 
      <span style="margin:0px; padding:0px; border:0px; font-style:inherit; font-variant:inherit; font-weight:inherit!important; font-size:inherit!important; line-height:inherit!important; font-family:inherit; vertical-align:baseline; height:inherit; color:rgb(0,153,153)!important">3.5</span> 
      <span style="margin:0px; padding:0px; border:0px; font-style:inherit; font-variant:inherit; font-weight:inherit!important; font-size:inherit!important; line-height:inherit!important; font-family:inherit; vertical-align:baseline; height:inherit; color:rgb(51,51,51)!important">)</span> 
      <span style="margin:0px; padding:0px; border:0px; font-style:inherit; font-variant:inherit; font-weight:inherit!important; font-size:inherit!important; line-height:inherit!important; font-family:inherit; vertical-align:baseline; height:inherit; color:rgb(51,51,51)!important">;</span> 
     </div> 
     <div style="margin:0px; padding:0px 5px; border:0px; font-style:inherit; font-variant:inherit; font-family:inherit; vertical-align:baseline; background:0px center; height:inherit; font-weight:inherit!important; font-size:inherit!important; line-height:inherit!important"> 
      <span style="margin:0px; padding:0px; border:0px; font-style:inherit; font-variant:inherit; font-weight:inherit!important; font-size:inherit!important; line-height:inherit!important; font-family:inherit; vertical-align:baseline; height:inherit; color:rgb(0,45,122)!important">std</span> 
      <span style="margin:0px; padding:0px; border:0px; font-style:inherit; font-variant:inherit; font-weight:inherit!important; font-size:inherit!important; line-height:inherit!important; font-family:inherit; vertical-align:baseline; height:inherit; color:rgb(0,111,224)!important">::</span> 
      <span style="margin:0px; padding:0px; border:0px; font-style:inherit; font-variant:inherit; font-family:inherit; vertical-align:baseline; height:inherit; font-weight:bold!important; font-size:inherit!important; line-height:inherit!important">cout</span> 
      <span style="margin:0px; padding:0px; border:0px; font-style:inherit; font-variant:inherit; font-weight:inherit!important; font-size:inherit!important; line-height:inherit!important; font-family:inherit; vertical-align:baseline; height:inherit; color:rgb(0,111,224)!important"> </span> 
      <span style="margin:0px; padding:0px; border:0px; font-style:inherit; font-variant:inherit; font-weight:inherit!important; font-size:inherit!important; line-height:inherit!important; font-family:inherit; vertical-align:baseline; height:inherit; color:rgb(0,111,224)!important">&lt;&lt;</span> 
      <span style="margin:0px; padding:0px; border:0px; font-style:inherit; font-variant:inherit; font-weight:inherit!important; font-size:inherit!important; line-height:inherit!important; font-family:inherit; vertical-align:baseline; height:inherit; color:rgb(0,111,224)!important"> </span> 
      <span style="margin:0px; padding:0px; border:0px; font-style:inherit; font-variant:inherit; font-weight:inherit!important; font-size:inherit!important; line-height:inherit!important; font-family:inherit; vertical-align:baseline; height:inherit; color:rgb(221,17,68)!important">'\n'</span> 
      <span style="margin:0px; padding:0px; border:0px; font-style:inherit; font-variant:inherit; font-weight:inherit!important; font-size:inherit!important; line-height:inherit!important; font-family:inherit; vertical-align:baseline; height:inherit; color:rgb(0,111,224)!important"> </span> 
      <span style="margin:0px; padding:0px; border:0px; font-style:inherit; font-variant:inherit; font-weight:inherit!important; font-size:inherit!important; line-height:inherit!important; font-family:inherit; vertical-align:baseline; height:inherit; color:rgb(0,111,224)!important">&lt;&lt;</span> 
      <span style="margin:0px; padding:0px; border:0px; font-style:inherit; font-variant:inherit; font-weight:inherit!important; font-size:inherit!important; line-height:inherit!important; font-family:inherit; vertical-align:baseline; height:inherit; color:rgb(0,111,224)!important"> </span> 
      <span style="margin:0px; padding:0px; border:0px; font-style:inherit; font-variant:inherit; font-weight:inherit!important; font-size:inherit!important; line-height:inherit!important; font-family:inherit; vertical-align:baseline; height:inherit; color:rgb(0,45,122)!important">f0</span> 
      <span style="margin:0px; padding:0px; border:0px; font-style:inherit; font-variant:inherit; font-weight:inherit!important; font-size:inherit!important; line-height:inherit!important; font-family:inherit; vertical-align:baseline; height:inherit; color:rgb(0,111,224)!important"> </span> 
      <span style="margin:0px; padding:0px; border:0px; font-style:inherit; font-variant:inherit; font-weight:inherit!important; font-size:inherit!important; line-height:inherit!important; font-family:inherit; vertical-align:baseline; height:inherit; color:rgb(0,111,224)!important">&lt;&lt;</span> 
      <span style="margin:0px; padding:0px; border:0px; font-style:inherit; font-variant:inherit; font-weight:inherit!important; font-size:inherit!important; line-height:inherit!important; font-family:inherit; vertical-align:baseline; height:inherit; color:rgb(0,111,224)!important"> </span> 
      <span style="margin:0px; padding:0px; border:0px; font-style:inherit; font-variant:inherit; font-weight:inherit!important; font-size:inherit!important; line-height:inherit!important; font-family:inherit; vertical-align:baseline; height:inherit; color:rgb(221,17,68)!important">'\n'</span> 
      <span style="margin:0px; padding:0px; border:0px; font-style:inherit; font-variant:inherit; font-weight:inherit!important; font-size:inherit!important; line-height:inherit!important; font-family:inherit; vertical-align:baseline; height:inherit; color:rgb(51,51,51)!important">;</span> 
     </div> 
    </div> </td> 
  </tr> 
 </tbody> 
</table>

这个例子的输出是 14.5 和 14.5。在这个例子中，f0 通过引用被捕获，而其它变量，比如 f1 则是通过值被捕获。

下面我们来总结下所有出现的 lambda 引入符：

*  `[]`        // 不捕获任何外部变量
 *  `[=]`      // 以值的形式捕获所有外部变量
 *  `[&]`      // 以引用形式捕获所有外部变量
 *  `[x, &y]` // x 以传值形式捕获，y 以引用形式捕获
 *  `[=, &z]`// z 以引用形式捕获，其余变量以传值形式捕获
 *  `[&, x]`  // x 以值的形式捕获，其余变量以引用形式捕获

另外有一点需要注意。对于`[=]`或`[&]`的形式，lambda 表达式可以直接使用 this 指针。但是，对于`[]`的形式，如果要使用 this 指针，必须显式传入：

C++

至此，我们已经大致了解了 C++ 11 提供的 lambda 表达式的概念。建议通过结合 lambda 表达式与`std::sort()`或`std::for_each()`这样的标准函数来尝试使用一下吧！

## 2.2  Auto 标识符 ##

转自  [auto标识符][auto]

标识出被声明的变量类型将会从它的初始化中自动推导得出。对于函数而言，标识出返回值类型是后置的返回值类型。

### 语法 ###

<table style="font-size:12.8px; color:rgb(0,0,0); font-family:DejaVuSans,&quot;DejaVu Sans&quot;,arial,sans-serif"> 
 <tbody> 
  <tr> 
   <td colspan="10" style="border-top:1px solid rgb(204,204,204); padding:0px"> &nbsp;</td> 
  </tr> 
  <tr> 
   <td style="padding:0.5em 0px 0.5em 1em; font-size:1em"><span style="line-height:1.1em"><span style="font-family:monospace; line-height:1.1em; white-space:nowrap"><span style="line-height:1.1em; color:rgb(0,0,255)">auto</span></span></span>&nbsp;<span style="color:rgb(128,128,128); font-style:italic; line-height:1.1em">variable</span>&nbsp;<span style="color:rgb(128,128,128); font-style:italic; line-height:1.1em">initializer</span>&nbsp;<span style="color:rgb(0,128,0); font-size:0.8em; line-height:1.1em">(C++11起)</span></td> 
   <td style="padding-left:3em">&nbsp;</td> 
   <td style="padding-left:2em">&nbsp;</td> 
  </tr> 
  <tr> 
   <td colspan="10" style="border-top:1px solid rgb(204,204,204); padding:0px"> &nbsp;</td> 
  </tr> 
  <tr> 
   <td style="padding:0.5em 0px 0.5em 1em; font-size:1em"><span style="line-height:1.1em"><span style="font-family:monospace; line-height:1.1em; white-space:nowrap"><span style="line-height:1.1em; color:rgb(0,0,255)">auto</span></span></span>&nbsp;<span style="color:rgb(128,128,128); font-style:italic; line-height:1.1em">function</span>&nbsp;-&gt;&nbsp;<span style="color:rgb(128,128,128); font-style:italic; line-height:1.1em">return type</span>&nbsp;<span style="color:rgb(0,128,0); font-size:0.8em; line-height:1.1em">(C++11起)</span></td> 
   <td style="padding-left:3em">&nbsp;</td> 
   <td style="padding-left:2em">&nbsp;</td> 
  </tr> 
  <tr> 
   <td colspan="10" style="border-top:1px solid rgb(204,204,204); padding:0px"> &nbsp;</td> 
  </tr> 
 </tbody> 
</table>

### 解释 ###

1) 在块作用域、命名空间作用域、for循环的初始化语句内声明变量的时候，变量的类型可以被省略，使用关键字auto来代替。

一旦初始化类型确定下来，编译器将决定能够替换关键字auto的类型类型，就像使用函数调用时的模板参数推导的规则一样。关键字auto能够伴随着修饰词，例如const或&，它们同样参与推导。例如，const auto& i = expr;，当f(expr)被编译时，`i`的类型就是就是假想的模板template<class U> void f(const U& u)中的参数`u`的类型。

2) 在[函数声明][Link 95]的时候，关键字auto不表示自动类型检测。它仅仅是表示后置返回值的语法的一部分而已。

### 注释 ###

在 C++11 之前，auto的语义是[存储持续性说明][Link 96]。

### 例子 ###

#include <iostream>
    #include <cmath>
    #include <typeinfo>
     
    template<class T, class U>
    auto add(T t, U u) -> decltype(t + u) // the return type of add is the type of operator+(T,U)
    {
          
        return t + u;
    }
     
    auto get_fun(int arg)->double(*)(double) // same as double (*get_fun(int))(double)
    {
          
        switch (arg) {
          
            case 1: return std::fabs;
            case 2: return std::sin;
            default: return std::cos;
        }
    }
     
    int main()
    {
          
        auto a = 1 + 2;
        std::cout << "type of a: " << typeid(a).name() << '\n';
        auto b = add(1, 1.2);
        std::cout << "type of b: " << typeid(b).name() << '\n';
        //auto int c; //compile-time error
        auto d = {
          1, 2};
        std::cout << "type of d: " << typeid(d).name() << '\n';
     
        auto my_lambda = [](int x) {
           return x + 3; };
        std::cout << "my_lambda: " << my_lambda(5) << '\n';
     
        auto my_fun = get_fun(2);
        std::cout << "type of my_fun: " << typeid(my_fun).name() << '\n';
        std::cout << "my_fun: " << my_fun(3) << '\n';
    }

输出：

type of a: int
    type of b: double
    type of d: std::initializer_list<int>
    my_lambda: 8
    type of my_fun: double (*)(double)
    my_fun: 0.14112

## 2.3 垃圾收集 ##

转自 [c++11改进我们的程序之垃圾回收][c_11]

c\#和java中有自动垃圾回收机制，.net运行时和java虚拟机可以管理分配的堆内存，在对象失去引用时自动回收，因此在c\#和jva中，   
内存管理不是大问题。c++语言没有垃圾回收机制，必须自己去释放分配的堆内存，否则就会内存泄露。  
　　我相信大部分c++开发人员都遇到过内存泄露的问题，而查找内存泄露的问题往往要花大量的精力。要解决这个让人头疼的问题可   
以采取一些办法，最有效的办法是使用智能指针！使用智能指针就不会担心内存泄露的问题了，因为智能指针可以自动删除删除分   
配的内存。

智能指针是指向动态分配（堆）对象指针，用于生存期控制，能够确保自动正确的销毁动态分配的对象，防止内存   
泄露。它的一种通用实现技术是使用引用计数。每次使用它，内部的引用计数加1，每次析构一次，内部引用计数减1，减为0时，删   
除所指向的堆内存。

c++11之前，c++没有内置智能指针，之前只能借助于boost的智能指针或者自己发明轮子。c++11现在内置的智能指针，使我们可以   
很方便的使用智能指针了。c++11中的智能指针包括：

*  std::shared\_ptr
 *  std::unique\_ptr
 *  std::weak\_ptr

**std::shared\_ptr**

std::shared\_ptr使用引用计数. 每一个shared\_ptr的拷贝都指向相同的内存。 在最后一个shared\_ptr析构的时候, 内存才会被释   
放。  
我们看看shared\_ptr如何使用吧。  
1.初始化

//智能指针的初始化
    std::shared_ptr<int> p(new int(2));
    std::shared_ptr<int> p2 = p;
    std::shared_ptr<BaseConnector> m_connt = make_shared<Connector>(m_ios, m_strIP, m_port);

通过构造函数、赋值函数或者make\_shared函数初始化智能指针。  
智能指针初始化可以指定删除器

![复制代码][copycode.gif]

void DeleteIntPtr(int* p)
    {
    delete p;
    }
    
    std::shared_ptr<int> p(new int, DeleteIntPtr);
    p的引用计数为0时会自动调用删除器DeleteIntPtr

![复制代码][copycode.gif]

2.智能指针中的原始指针，通过get获取  
char\* pData = pBuf.get();

3.注意事项。智能指针虽然能自动管理堆内存，但是它有不少陷阱，使用时需要注意：

*1.不要把一个原生指针给多个shared\_ptr管理*

int* ptr = new int;
    shared_ptr<int> p1(ptr);
    shared_ptr<int> p2(ptr); //logic error
    导致ptr被删除两次

*2.不要把this指针给shared\_ptr  
3.不要在函数实参里创建shared\_ptr *  
function ( shared\_ptr<int>(new int), g( ) ); //有缺陷  
可能的过程是先new int，然后调g( )，g( )发生异常，shared\_ptr<int>没有创建，int内存泄露  
shared\_ptr<int> p(new int());  
f(p, g());   
*4.对象内部生成this的shared\_ptr  *

enable\_shared\_from\_this 类，在该类中定了成员函数 shared\_from\_this() ，返回shared\_ptr<T> 。这个函数仅在 shared\_ptr<T> 的构造函数被调用之后才能使用。原因是 enable\_shared\_from\_this::weak\_ptr 并不在构造函数中设置（此处的构造函数指的是类型 T 的构造函数），而是在 shared\_ptr<T> 的构造函数中设置（此处的构造函数指的是类型 shared\_ptr<T> 的构造函数）。

若不使用 shared\_from\_this() 成员函数，将this指针构造了一个shared\_ptr，外面创建的对象本身的shared\_ptr也管理了this资源，在析构时则会发生两次析构；

![复制代码][copycode.gif]

class Y: public std::enable_shared_from_this<Y>
    {
    boost::shared_ptr<Y> GetSelf()
    {
    return shared_from_this();
    }
    };
    
    boost::shared_ptr<Y> spy(new Y)
    boost::shared_ptr<Y> p = spy->GetSelf(); //OK

![复制代码][copycode.gif]

*5.shared\_ptr作为对象的成员时，小心因循环引用造成无法释放资源。*

![复制代码][copycode.gif]

struct A;
    struct B;
    struct A
    {
    std::shared_ptr<B> m_b;
    };
    
    struct B
    {
    std::shared_ptr<A> m_a;
    };
    
    std::shared_ptr<A> ptrA(new A);
    std::shared_ptr<B> ptrB(new B);
    ptrA->m_b = ptrB;
    ptrB->m_a = ptrA;

![复制代码][copycode.gif]

ptrA和ptrB相互引用，离开作用域时引用计数都为1，导致内存没有被释放，解决办法是把A和B任何一个的成员变量改为weak\_ptr  
解决办法是把A和B任何一个的成员变量改为weak\_ptr

struct B  
\{  
std::weak\_ptr<A> m\_a;  
\};

ptrB->m\_a不会增加A对象的引用计数，因此A对象离开作用域时，引用计数为0，m\_b的引用计数减一，b离开作用域后引用计数由1减为0.

**std::weak\_ptr**  
弱引用指针，用来监视智能指针，不会使引用计数加1。在访问所引用的对象前必须先转换为 std::shared\_ptr。

用来表达临时所有权的概念：当某个对象只有存在时才需要被访问，而且随时可能被他人删除时，可以使用

来跟踪该对象。需要获得临时所有权时，则将其转换为 std::shared\_ptr，此时如果原来的std::shared\_ptr 被销毁，则该对象的生命期将被延长至这个临时的 std::shared\_ptr 同样被销毁为止。

还可以用来避免 std::shared\_ptr 的循环引用。

![复制代码][copycode.gif]

std::weak_ptr<int> gw; 
    void f()
    {
    if (auto spt = gw.lock()) { // Has to be copied into a shared_ptr before usage
    std::cout << *spt << "\n";
    }
    else {
    std::cout << "gw is expired\n";
    }
    }
    
    int main()
    {
    {
    auto sp = std::make_shared<int>(42);
    gw = sp;
    f();
    }
    f();
    }
    输出
    42 
    gw is expired

![复制代码][copycode.gif]

###  std::unique\_ptr ###

unique_ptr不会共享它的指针。 无法将它复制到另一个unique_ptr， unique_ptr只能移动。 这意味着内存资源的所有权将转移到新的unique_ptr和原始unique_ptr不再拥有它。

int* p = new int;
    std::unique_ptr<int> ptr(p);
    std::unique_ptr<int> ptr1 = ptr; //不能复制，编译报错
    
    auto ptr2 = std::move(ptr); //转移所有权, 现在ptr那块内存归ptr2所有, ptr成为无效的指针.

智能指针是个好东西，使用它之后就不用担心内存释放、内存泄露的问题了，我的项目中都是用的智能指针，没有delete。

智能指针使我们的程序更安全，除了循环引用会导致内存泄露之外，其他都很安全，可以放心使用。

[https_zh.wikipedia.org_wiki_C_2B_2B11]: https://zh.wikipedia.org/wiki/C%2B%2B11
[C]: https://zh.wikipedia.org/wiki/C%2B%2B%E7%BC%96%E7%A8%8B%E8%AF%AD%E8%A8%80
[Link 1]: https://zh.wikipedia.org/wiki/%E6%A0%B8%E5%BF%83%E8%AA%9E%E8%A8%80
[C 1]: https://zh.wikipedia.org/wiki/C%2B%2B%E6%A8%99%E6%BA%96%E7%A8%8B%E5%BC%8F%E5%BA%AB
[C_ Technical Report 1]: https://zh.wikipedia.org/wiki/C%2B%2B_Technical_Report_1
[ISO C_]: http://www.open-std.org/jtc1/sc22/wg21/docs/papers/
[ISO]: https://zh.wikipedia.org/wiki/ISO
[IEC]: https://zh.wikipedia.org/wiki/IEC
[1]: https://zh.wikipedia.org/wiki/C%2B%2B11#endnote_strousup-brieflooka
[N3376]: http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2012/n3376.pdf
[Link 2]: https://zh.wikipedia.org/wiki/%E7%A8%8B%E5%BC%8F%E8%AA%9E%E8%A8%80
[Bjarne Stroustrup]: https://zh.wikipedia.org/wiki/Bjarne_Stroustrup
[C 2]: https://zh.wikipedia.org/wiki/C%E8%AA%9E%E8%A8%80
[Link 3]: https://zh.wikipedia.org/wiki/%E5%A4%9A%E5%9F%B7%E8%A1%8C%E7%B7%92_%28%E9%9B%BB%E8%85%A6%E7%A1%AC%E9%AB%94%29
[Link 4]: https://zh.wikipedia.org/wiki/%E6%B3%9B%E5%9E%8B%E7%BC%96%E7%A8%8B
[Link 5]: https://zh.wikipedia.org/wiki/C%2B%2B11#.E4.B8.8D.E5.AE.9A.E9.95.B7.E5.8F.83.E6.95.B8.E6.A8.A1.E6.9D.BF
[plain old data]: https://en.wikipedia.org/wiki/Plain_Old_Data_Structures
[Link 6]: https://zh.wikipedia.org/wiki/C%2B%2B11#.E4.BD.BF.E7.94.A8.E6.88.96.E7.A6.81.E7.94.A8.E7.89.A9.E4.BB.B6.E7.9A.84.E9.A0.90.E8.A8.AD.E5.87.BD.E5.BC.8F
[Link 7]: https://zh.wikipedia.org/wiki/%E6%A8%A1%E6%9D%BF%E8%B6%85%E7%B7%A8%E7%A8%8B
[Link 8]: https://zh.wikipedia.org/wiki/%E8%BF%AD%E4%BB%A3%E5%99%A8
[lambda]: https://zh.wikipedia.org/wiki/%CE%9B%E6%BC%94%E7%AE%97
[Link 9]: https://zh.wikipedia.org/wiki/%E9%97%AD%E5%8C%85_%28%E8%AE%A1%E7%AE%97%E6%9C%BA%E7%A7%91%E5%AD%A6%29
[delegation]: https://zh.wikipedia.org/w/index.php?title=Delegation&action=edit&redlink=1
[Java]: https://zh.wikipedia.org/wiki/Java
[C 3]: https://zh.wikipedia.org/wiki/C
[0]: https://zh.wikipedia.org/wiki/0
[1 1]: https://zh.wikipedia.org/wiki/C%2B%2B11#cite_note-1
[Link 10]: https://zh.wikipedia.org/w/index.php?title=%E5%8F%98%E9%95%BF%E5%8F%82%E6%95%B0%E6%A8%A1%E6%9D%BF&action=edit&redlink=1
[Unicode]: https://zh.wikipedia.org/wiki/Unicode
[UTF-8]: https://zh.wikipedia.org/wiki/UTF-8
[UTF-16]: https://zh.wikipedia.org/wiki/UTF-16
[UTF-32]: https://zh.wikipedia.org/wiki/UTF-32
[XML]: https://zh.wikipedia.org/wiki/XML
[Link 11]: https://zh.wikipedia.org/wiki/%E8%85%B3%E6%9C%AC%E8%AA%9E%E8%A8%80
[computing]: https://zh.wikipedia.org/w/index.php?title=%E5%86%85%E5%AD%98%E6%A8%A1%E5%9E%8B%28computing%29&action=edit&redlink=1
[Link 12]: https://zh.wikipedia.org/wiki/%E5%A4%9A%E7%BA%BF%E7%A8%8B
[Link 13]: https://zh.wikipedia.org/wiki/C%2B%2B11#.E7.B7.92.E7.A8.8B.E6.94.AF.E6.8F.B4
[Link 14]: https://zh.wikipedia.org/w/index.php?title=%E7%BC%96%E8%AF%91%E5%99%A8%E7%9A%84%E6%9C%80%E4%BD%B3%E5%8C%96&action=edit&redlink=1
[C99]: https://zh.wikipedia.org/wiki/C99
[Link 15]: https://zh.wikipedia.org/w/index.php?title=%E5%89%8D%E8%99%95%E7%90%86%E5%99%A8&action=edit&redlink=1
[Link 16]: https://zh.wikipedia.org/wiki/%E7%A8%8B%E5%BC%8F%E5%BA%AB
[C_Library Technical Report]: https://zh.wikipedia.org/wiki/TR1
[Link 17]: https://zh.wikipedia.org/wiki/%E5%91%BD%E5%90%8D%E7%A9%BA%E9%97%B4
[Link 18]: https://zh.wikipedia.org/wiki/%E5%A4%9A%E5%85%83%E7%BB%84
[_linear chaining]: https://zh.wikipedia.org/wiki/C%2B%2B11#.E5.93.88.E5.B8.8C.E8.A1.A8
[Link 19]: https://zh.wikipedia.org/wiki/%E6%AD%A3%E8%A6%8F%E8%A1%A8%E7%A4%BA%E5%BC%8F
[Link 20]: https://zh.wikipedia.org/wiki/%E9%9D%A2%E5%90%91%E5%AF%B9%E8%B1%A1%E8%AF%AD%E8%A8%80
[raw string]: https://zh.wikipedia.org/wiki/C%2B%2B11#.E6.96.B0.E7.9A.84.E5.AD.97.E4.B8.B2.E5.AD.97.E9.9D.A2.E5.80.BC
[Link 21]: https://zh.wikipedia.org/wiki/%E4%BC%AA%E9%9A%8F%E6%9C%BA%E6%95%B0
[Link 22]: https://zh.wikipedia.org/wiki/%E9%9B%A2%E6%95%A3%E5%9E%8B%E5%9D%87%E5%8B%BB%E5%88%86%E4%BD%88
[Link 23]: https://zh.wikipedia.org/wiki/%E4%BC%AF%E5%8A%AA%E5%88%A9%E5%88%86%E5%B8%83
[Link 24]: https://zh.wikipedia.org/wiki/%E5%B9%BE%E4%BD%95%E5%88%86%E4%BD%88
[Link 25]: https://zh.wikipedia.org/wiki/%E5%8D%9C%E7%93%A6%E6%9D%BE%E5%88%86%E4%BD%88
[Link 26]: https://zh.wikipedia.org/wiki/%E4%BA%8C%E9%A0%85%E5%88%86%E4%BD%88
[Link 27]: https://zh.wikipedia.org/wiki/%E6%8C%87%E6%95%B0%E5%88%86%E5%B8%83
[Link 28]: https://zh.wikipedia.org/wiki/%E5%B8%B8%E6%85%8B%E5%88%86%E4%BD%88
[Link 29]: https://zh.wikipedia.org/wiki/%E4%BC%BD%E7%8E%9B%E5%88%86%E5%B8%83
[Link 30]: https://zh.wikipedia.org/wiki/%E5%85%83%E7%BC%96%E7%A8%8B
[Link 31]: https://zh.wikipedia.org/wiki/%E6%A8%A1%E6%9D%BF
[Link 32]: https://zh.wikipedia.org/wiki/%E6%B3%9B%E5%9E%8B
[decltype]: https://zh.wikipedia.org/wiki/C%2B%2B11#.E5.9E.8B.E5.88.A5.E6.8E.A8.E5.B0.8E
[Link 33]: http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2316.pdf
[_C]: https://zh.wikipedia.org/wiki/%E6%A6%82%E5%BF%B5_%28C%2B%2B%29
[sequence point]: https://en.wikipedia.org/wiki/Sequence_point
[export]: https://en.wikipedia.org/wiki/export_%28C%2B%2B%29
[exception specification]: https://en.wikipedia.org/wiki/exception_specification
[std_auto_ptr]: https://en.wikipedia.org/wiki/std::auto_ptr
[Visual C]: https://zh.wikipedia.org/wiki/Visual_C%2B%2B
[C_0x Core Language Features In VC10_ The Table]: http://blogs.msdn.com/b/vcblog/archive/2010/04/06/c-0x-core-language-features-in-vc10-the-table.aspx
[GCC]: https://zh.wikipedia.org/wiki/GCC
[Status of Experimental C_0x Support in GCC 4.6]: http://gcc.gnu.org/gcc-4.6/cxx0x_status.html
[C11]: https://zh.wikipedia.org/wiki/C%E8%AA%9E%E8%A8%80#C11
[C_1y]: https://zh.wikipedia.org/w/index.php?title=C%2B%2B1y&action=edit&redlink=1
[Link 34]: https://zh.wikipedia.org/wiki/C%2B%2B11#cite_ref-1
[N2544]: http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2544.pdf
[Link 35]: https://zh.wikipedia.org/wiki/C%2B%2B11#ref_n1401
[1401]: http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2002/n1401.pdf
[Link 36]: https://zh.wikipedia.org/wiki/C%2B%2B11#ref_n1402
[1402]: http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2002/n1402.html
[Link 37]: https://zh.wikipedia.org/wiki/C%2B%2B11#ref_n1403
[1403]: http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2002/n1403.pdf
[Link 38]: https://zh.wikipedia.org/wiki/C%2B%2B11#ref_n1424
[1424]: http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2003/n1424.htm
[Link 39]: https://zh.wikipedia.org/wiki/C%2B%2B11#ref_n1429
[1429]: http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2003/n1429.htm
[Link 40]: https://zh.wikipedia.org/wiki/C%2B%2B11#ref_n1449
[1449]: http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2003/n1449.pdf
[Link 41]: https://zh.wikipedia.org/wiki/C%2B%2B11#ref_n1450
[1450]: http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2003/n1450.html
[Link 42]: https://zh.wikipedia.org/wiki/C%2B%2B11#ref_n1452
[1452]: http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2003/n1452.html
[Link 43]: https://zh.wikipedia.org/wiki/C%2B%2B11#ref_n1453
[1453]: http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2003/n1453.html
[Link 44]: https://zh.wikipedia.org/wiki/C%2B%2B11#ref_n1454
[1454]: http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2003/n1454.html
[Link 45]: https://zh.wikipedia.org/wiki/C%2B%2B11#ref_n1456
[1456]: http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2003/n1456.html
[Link 46]: https://zh.wikipedia.org/wiki/C%2B%2B11#ref_n1471
[1471]: http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2003/n1471.pdf
[Link 47]: https://zh.wikipedia.org/wiki/C%2B%2B11#ref_n1676
[1676]: http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2004/n1676.htm
[Link 48]: https://zh.wikipedia.org/wiki/C%2B%2B11#ref_n1704
[1704]: http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2004/n1704.pdf
[Link 49]: https://zh.wikipedia.org/wiki/C%2B%2B11#ref_n1705
[1705]: http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2004/n1705.pdf
[Link 50]: https://zh.wikipedia.org/wiki/C%2B%2B11#ref_n1717
[1717]: http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2004/n1717.pdf
[Link 51]: https://zh.wikipedia.org/wiki/C%2B%2B11#ref_n1719
[1719]: http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2004/n1719.pdf
[Link 52]: https://zh.wikipedia.org/wiki/C%2B%2B11#ref_n1720
[1720]: http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2004/n1720.html
[Link 53]: https://zh.wikipedia.org/wiki/C%2B%2B11#ref_n1757
[1757]: http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2005/n1757.html
[Link 54]: https://zh.wikipedia.org/wiki/C%2B%2B11#ref_n1811
[1811]: http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2005/n1811.pdf
[Link 55]: https://zh.wikipedia.org/wiki/C%2B%2B11#ref_n1815
[1815]: http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2005/n1815.html
[Link 56]: https://zh.wikipedia.org/wiki/C%2B%2B11#ref_n1827
[1827]: http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2005/n1827.htm
[Link 57]: https://zh.wikipedia.org/wiki/C%2B%2B11#ref_n1834
[1834]: http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2005/n1834.html
[Link 58]: https://zh.wikipedia.org/wiki/C%2B%2B11#ref_n1836
[1836]: http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2005/n1836.pdf
[Link 59]: https://zh.wikipedia.org/wiki/C%2B%2B11#ref_n1886
[1886]: http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2005/n1886.pdf
[Link 60]: https://zh.wikipedia.org/wiki/C%2B%2B11#ref_n1891
[1891]: http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2005/n1891.pdf
[Link 61]: https://zh.wikipedia.org/wiki/C%2B%2B11#ref_n1898
[1898]: http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2005/n1898.pdf
[Link 62]: https://zh.wikipedia.org/wiki/C%2B%2B11#ref_n1919
[1919]: http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2005/n1919.pdf
[Link 63]: https://zh.wikipedia.org/wiki/C%2B%2B11#ref_n1968
[1968]: http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2006/n1968.pdf
[Link 64]: https://zh.wikipedia.org/wiki/C%2B%2B11#ref_n1986
[1986]: http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2006/n1986.pdf
[Link 65]: https://zh.wikipedia.org/wiki/C%2B%2B11#ref_n2016
[2016]: http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2006/n2016.html
[Link 66]: https://zh.wikipedia.org/wiki/C%2B%2B11#ref_n2142
[2142]: http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2142.html
[Link 67]: https://zh.wikipedia.org/wiki/C%2B%2B11#ref_n2228
[2228]: http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2228.html
[Link 68]: https://zh.wikipedia.org/wiki/C%2B%2B11#ref_n2258
[2258]: http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2258.pdf
[Link 69]: https://zh.wikipedia.org/wiki/C%2B%2B11#ref_n2280
[2280]: http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2280.html
[Link 70]: https://zh.wikipedia.org/wiki/C%2B%2B11#ref_n2291
[2291]: http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2291.html
[Link 71]: https://zh.wikipedia.org/wiki/C%2B%2B11#ref_n2336
[2336]: http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2336.html
[Link 72]: https://zh.wikipedia.org/wiki/C%2B%2B11#ref_n2389
[2389]: http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2389.html
[Link 73]: https://zh.wikipedia.org/wiki/C%2B%2B11#ref_n2431
[2431]: http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2431.pdf
[Link 74]: https://zh.wikipedia.org/wiki/C%2B%2B11#ref_n2432
[2432]: http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2432.html
[Link 75]: https://zh.wikipedia.org/wiki/C%2B%2B11#ref_n2437
[2437]: http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2437.pdf
[Link 76]: https://zh.wikipedia.org/wiki/C%2B%2B11#ref_n2461
[2461]: http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2461.pdf
[Link 77]: https://zh.wikipedia.org/wiki/C%2B%2B11#ref_n2507
[2507]: http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2507.html
[Link 78]: https://zh.wikipedia.org/wiki/C%2B%2B11#ref_n2544
[Link 79]: https://zh.wikipedia.org/wiki/C%2B%2B11#ref_n2565
[2565]: http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2565.html
[Link 80]: https://zh.wikipedia.org/wiki/C%2B%2B11#ref_n2597
[2597]: http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2597.html
[Link 81]: https://zh.wikipedia.org/wiki/C%2B%2B11#ref_n2606
[2606]: http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2606.pdf
[Link 82]: https://zh.wikipedia.org/wiki/C%2B%2B11#ref_n2697
[2697]: http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2697.html
[Link 83]: https://zh.wikipedia.org/wiki/C%2B%2B11#ref_n2798
[2798]: http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2798.pdf
[Link 84]: https://zh.wikipedia.org/wiki/C%2B%2B11#ref_n2857
[2857]: http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2009/n2857.pdf
[Link 85]: https://zh.wikipedia.org/wiki/C%2B%2B11#ref_n2869
[2869]: http://www.open-std.org/JTC1/SC22/WG21/docs/papers/2009/n2869.html
[Link 86]: https://zh.wikipedia.org/wiki/C%2B%2B11#ref_n3000
[3000]: http://www.open-std.org/JTC1/SC22/WG21/docs/papers/2009/n3000.pdf
[Link 87]: https://zh.wikipedia.org/wiki/C%2B%2B11#ref_n3014
[3014]: http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2009/n3014.pdf
[Link 88]: https://zh.wikipedia.org/wiki/C%2B%2B11#ref_n3082
[3082]: http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2010/n3082.pdf
[Link 89]: https://zh.wikipedia.org/wiki/C%2B%2B11#ref_n3092
[3092]: http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2010/n3092.pdf
[Link 90]: https://zh.wikipedia.org/wiki/C%2B%2B11#ref_n3126
[3126]: http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2010/n3126.pdf
[Link 91]: https://zh.wikipedia.org/wiki/C%2B%2B11#ref_n3225
[3225]: http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2010/n3225.pdf
[Link 92]: https://zh.wikipedia.org/wiki/C%2B%2B11#ref_n3242
[3242]: http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2011/n3242.pdf
[Link 93]: https://zh.wikipedia.org/wiki/C%2B%2B11#ref_n3290
[3290]: http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2011/n3290.pdf
[a]: https://zh.wikipedia.org/wiki/C%2B%2B11#ref_strousup-brieflooka
[b]: https://zh.wikipedia.org/wiki/C%2B%2B11#ref_strousup-brieflookb
[Link 94]: https://zh.wikipedia.org/wiki/C%2B%2B11#ref_strousup-designof
[Informit.com]: https://zh.wikipedia.org/w/index.php?title=Informit.com&action=edit&redlink=1
[A Brief Introduction to Rvalue References]: http://www.artima.com/cppsource/rvalue.html
[C_0x_ The Dawning of a New Standard]: http://www.devx.com/SpecialReports/Door/38865
[The C_ Standards_Committee]: http://www.open-std.org/jtc1/sc22/wg21/
[Bjarne Stroustrup_s homepage]: http://www.research.att.com/~bs/
[C_0X_ The New Face of Standard C]: http://www.informit.com/guides/content.aspx?g=cplusplus&seqNum=216
[Herb Sutter_s blog coverage of C_0X]: http://herbsutter.wordpress.com/
[A talk on C_0x given by Bjarne Stroustrup at the University of Waterloo]: http://www.csclub.uwaterloo.ca/media/C++0x%20-%20An%20Overview.html
[A quick and dirty introduction to C_0x _as of November 2007]: http://www.pvv.org/~oma/cpp0x_aquadi_nov_2007.pdf
[The State of the Language_ An Interview with Bjarne Stroustrup _August 15_ 2008]: http://www.devx.com/SpecialReports/Article/38813/0/page/1
[C_11 _Lambda]: https://www.devbean.net/2012/05/cpp11-lambda/
[auto]: http://zh.cppreference.com/w/cpp/language/auto
[Link 95]: http://zh.cppreference.com/w/cpp/language/function
[Link 96]: http://zh.cppreference.com/w/cpp/language/storage_duration
[c_11]: http://www.cnblogs.com/qicosmos/p/3282779.html
[copycode.gif]: /images/20220224/42379317f00340fab01fef77eed5869b.png