C++最新标准C++ 0x详细介绍

 

        C++是具有国际标准的编程语言，通常称作ANSI/ISO C++，1998年国际标准组织（ISO）颁布了C++语言的国际标准ISO/IEC 1488-1998。。1998年是C++标准委员会成立的第一年，以后每5年视实际需要更新一次标准，最近一次标准更新是在2009年，目前我们一般称该标准C++0x。遗憾的是，由于C++语言过于复杂，以及他经历了长年的演变，直到2009年只有Visual C++ 2010 CTP开发环境的编译器完全符合这个标准。C++委员会的主要焦点是在语言核心的发展上，C++0x关于核心语言的领域将被大幅改善，包括多线程支持、 泛型编程、统一的初始化，以及表现的加强。

        成为国际标准　　C++0x最终国际投票已于2011年8月10日结束，所有国家都投出了赞成票。国际标准化组织 于 2011年9月1日出版发布ISO/IEC 14882:2011，名称是

　　Information technology -- Programming languages -- C++ Edition: 3

　　C++ 2011 正式成为新的C++标准

　　C++ 2011将取代现行的C++标准ISO/IEC 14882，它公开于1998年并于2003年更新，通称C++98以及C++03。

　　新标准的pdf文档可以在其iso官方网站购买获取。

核心语言扩充

　　C++委员会的主要焦点是在语言核心的发展上。因此C++0x的发表日期取决于这部份标准的作业进度。

　　核心语言的领域将被大幅改善，包括多线程支持、 泛型编程、统一的初始化，以及表现的加强。

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

　　2011年3月27日，IS0 C++ 委员会正式批准了C++编程语言国际标准最终草案(FDIS)。标准本身已经完成，接下来将是根据委员会会议修改意见更新工作草案，预计将用三周时间完成FDIS草案，然后交给日内瓦的ITTF，最新的C++标准将在夏天发布，先前被临时命名为C++0x的新标准将被称为C++ 2011。从2003年发布的C++03到2011年的C++ 2011，新标准的制定历经了8年时间。GCC和Visual C++编译器都已加入了C++2011/C++0x的支持。

核心语言的运行期表现强化

右值引用与转移语义

　　在旧标准C++语言中，临时量（术语为右值，因其出现在赋值表达式的右边）可以做参数传给函数，但只能被接受为const &类型。这样函数便无法区分传给const &的是真正的右值还是普通const变量。而且，由于类型为const &，函数也无法改变所传对象的值。

　　C++0x将增加一种名为右值引用的新的引用类型，记作typename &&。这种类型可以被接受为非const值，从而允许改变其值。这种改变将允许某些对象创建转移语义。

　　比如，一个std::vector，就其内部实现而言，是一个C式数组的封装。如果需要创建vector临时量或者从函数中返回vector，那就只能通过创建一个新的vector并拷贝所有存于右值中的数据来存储数据。之后这个临时的vector则会被销毁，同时删除其包含的数据。

　　有了右值引用，一个参数为指向某个vector的右值引用的std::vector的转移构造器就能够简单地将该右值中C式数组的指针复制到新的vector，然后将该右值清空。这里没有数组拷贝，并且销毁被清空的右值也不会销毁保存数据的内存。返回vector的函数现在只需要返回一个std::vector<>&&。如果vector没有转移构造器，那么结果会像以前一样：用std::vector<> &参数调用它的拷贝构造器。如果vector确实具有转移构造器，那么转移构造器就会被调用，从而避免大量的内存分配。

　　考虑到安全因素，具名变量即使被声明为右值类型也不会被当作右值。如需把它当作右值，须使用库函数std::move()。

　　bool is_r_value(int &&)

　　{

　　return true;

　　}

　　bool is_r_value(const int &)

　　{

　　return false;

　　}

　　void test(int &&i)

　　{

　　is_r_value(i); // false

　　is_r_value(std::move(i)); // true

　　}

　　出于右值引用定义的本质特征以及某些对左值引用（常规引用）定义的修改，现在右值引用允许程序员提供函数参数的完美转发。当与模板变参相结合时，这种能力可以允许函数模板完美地将参数转发给接受那些参数的其他函数。这在转发构造器参数时尤为有用：可以创建一些能自动调用具有相应参数构造器的工厂函数。

泛化的常数表示式

　　C++语言一直具有常量表达式的概念。这些诸如3+4之类的表达式总是产生相同的结果且不具备副作用。常量表达式给编译器带来了优化的可能，而编译器也经常在编译期执行此类表达式并将结果存放在程序中。此外，C++语言规范中有一些地方需要使用常量表达式。定义数组需要常量表达式，而枚举值也必须是常量表达式。

　　然而，每当碰到函数调用或对象构造，常量表达式便不再有效。所以简单如下例便不合法：

　　int GetFive()

　　{

　　return 5;

　　}

　　int some_value[GetFive() + 5]; //创建一个包含10个整型变量的数组，在标准C++中不合法

　　这段代码在C++中不合法，因为GetFive() + 5不是一个常量表达式。编译器无从知晓GetFive在运行期是否产生常量。理论上，这个函数可能会影响某个全局变量，或者调用其他运行期产生非常量的函数。

　　C++0x将引入constexpr关键字，此关键字将使用户能保证某个函数或构造器在编译期产生常量。上例可被改写如下：

　　constexpr int GetFive()

　　{

　　return 5;

　　}

　　int some_value[GetFive() + 5]; //在标准C++0x中合法

　　这段代码将使编译器理解并确认GetFive是个编译期常量。

　　在函数上使用constexpr将对函数功能施加严格的限制。首先，函数必须返回非void类型。其次，函数体必须具有"return /expr/"的形式。第三，expr在参数替换后必须是常量表达式。该常量表达式只能调用其他定义为constexpr的函数，只能使用其他常量表达式数据变量。第四，常量表达式中一切形式的递归均被禁止。最后，这种带constexpr的函数在编译单元中必须先定义后调用。

　　变量也可被定义为常量表达式值。

　　constexpr double forceOfGravity = 9.8;

　　constexpr double moonGravity = forceOfGravity / 6;

　　常量表达式数据变量隐含为常量。它们只能存放常量表达式或常量表达式构造器的结果。

　　为了从用户自定义类型中构建常量表达式数据值，构造器在声明时可带constexpr。同常量表达式函数一样，在编译单元中常量表达式构造器也必须先定义后使用。常量表达式构造器函数体必须为空，而且它必须用常量表达式构造其成员。这种类型的析构器必须是平凡的。

　　由常量表达式拷贝构造的类型也必须被定义为constexpr，以使它们能从常量表达式函数中作为值被返回。类的任何成员函数，包括拷贝构造器和操作符重载，都能被声明为constexpr，只要它们符合常量表达式函数的定义。这就允许编译器在编译期不仅能拷贝类对象，也能对其实施其他操作。

　　常量表达式函数或构造器可以用非constexpr参数来调用。就如同一个constexpr整数常量可以被赋给一个非constexpr变量一样，constexpr函数也可用非constexpr参数来调用，并且其结果也可存放在非constexpr变量中。此关键字只是提供了在一个表达式的全部成员均为constexpr时其结果为编译期常量的可能性。

对POD定义的修正

　　在标准C++语言中，要让结构成为POD类型必须满足某几条规则。有充分理由让一大堆类型满足这些规则（定义）；只要满足这些规则，结构的实现将产生兼容于C的对象布局。然而，在C++03中这些规则过于严格。注：POD，Plain Old Data，指POD用来表明C++中与C相兼容的数据类型，可以按照C的方式来处理（运算、拷贝等）。非POD数据类型与C不兼容，只能按照C++特有的方式进行使用。

　　C++0x将放松某些关于POD的限制规则。

　　如果一个类或结构是平凡的，具有标准布局的，且不包含任何非POD的非静态成员，那么它就被认定是POD。平凡的类或结构定义如下：

　　1.具有一个平凡的缺省构造器。（可以使用缺省构造器语法，如 SomeConstructor() = default;)

　　2.具有一个平凡的拷贝构造器。（可以使用缺省构造器语法)

　　3.具有一个平凡的拷贝赋值运算符。（可以使用缺省语法)

　　4.具有一个非虚且平凡的析构器。

　　一个具有标准布局的类或结构被定义如下：

　　1.所有非静态数据成员均为标准布局类型。

　　2.所有非静态成员的访问权限(public, private, protected) 均相同。

　　3.没有虚函数。

　　4.没有虚基类。

　　5.所有基类均为标准布局类型。

　　6.没有任何基类的类型与类中第一个非静态成员相同。

　　7.要么全部基类都没有非静态数据成员，要么最下层的子类没有非静态数据成员且最多只有一个基类有非静态数据成员。总之继承树中最多只能有一个类有非静态数据成员。所有非静态数据成员必须都是标准布局类型。

[ 附关于POD的说明：] 

PLAIN OLD DATA

　　plain old data 的缩写（POD）一个普通的古老的数据结构(POD)是一种数据结构。它仅作为被动的收藏的字段值,不使用封包或者otherobject-oriented特征。(A plain old data structure(POD) is a data structurethat is represented only as passive collections of field values, without using encapsulationor otherobject-orientedfeatures.)

　　在C++中，我们把传统的C风格的struct叫做POD（Plain Old Data）对象。一般来说，POD对象应该满足如下特性。

　　对于POD类型T的对象，不管这个对象是否拥有类型T的有效值，如果将该对象的底层字节序列复制到一个字符数组（或者无符号字符数组）中，再将其复制回对象，那么该对象的值与原始值一样。考试就到

　　对于任意的POD类型T，如果两个T指针分别指向两个不同的对象obj1和obj2，如果用memcpy库函数把obj1的值复制到obj2，那么obj2将拥有与obj1相同的值。

　　简言之，针对POD对象，其二进制内容是可以随便复制的，在任何地方，只要其二进制内容在，就能还原出正确无误的POD对象。对于任何POD对象，都可以使用memset()函数或者其他类似的内存初始化函数。

核心语言建构期表现的加强

外部模板

　　在标准C++语言中，如果在某一个编译单元中编译器碰到一个参数完全指定的模板，它就必须实例化该模板。这种做法可能大大延长编译时间，尤其在许多编译单元使用同样的参数实例化该模板时。

　　C++0x将引入外部模板的概念。C++已经拥有了迫使编译器在某一地点实例化模板的语法：

　　template class std::vector<MyClass>;

　　C++所缺乏的是防止编译器具现化某个模板的能力。C++0x只是简单地将语法扩展为：

　　extern template class std::vector<MyClass>;

　　这段代码将告诉编译器不要在这个编译单元实例化此模板。

核心语言使用性的加强

初始化列表

　　标准C++语言从C语言中借入了初始化列表概念。根据这一概念，结构或数组可以通过给定一串按照结构中成员定义的次序排列的参数来创建。初始化列表可以递归创建，因此结构数组或包含其他结构的结构也能使用初始化列表。这对于静态列表或用某些特定值初始化结构而言非常有用。C++语言中存在能让对象初始化的构造器特性。但构造器特性本身并不能取代初始化列表的所有功能。标准C++允许类和结构使用初始化列表，但它们必须满足POD的定义。非POD的类不能使用初始化列表，一些C++式的容器如std::vector和boost::array也不行。

　　C++0x将把初始化列表绑定为一种名为std::initializer_list的类型。这将允许构造器及其他函数接受初始化列表作为其参数。比如：

　　class SequenceClass

　　{

　　public:

　　SequenceClass(std::initializer_list < int >list);

　　};

　　这段代码将允许SequenceClass用一串整数构造，如下所示：

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

　　这种构造器是一种特殊类型的构造器，名为初始化列表构造器。具有这种构造器的类在统一的初始化形式中将被特殊对待。

　　std::initializer_list<>类在C++0x标准库中将成为一等公民。但是这个类的对象只能通过使用{}语法由C++0x编译器静态构建并初始化。列表一旦构建即可被拷贝，尽管只是引用拷贝。初始化列表是常量，一旦构建，组成列表的成员以及其成员所包含的数据便无法改变。

　　由于初始化列表是一种真实的类型，因此在类构造器之外的地方也能使用。常规函数也可接受初始化列表作为其参数。比如：

　　void FunctionName(std::initializer_list<float> list);

　　FunctionName({1.0f, -3.45f, -0.4f});

　　另外，标准容器也可用初始化列表初始化。比如：

　　vector<string> DayOfWeek={"Monday", "Tuesday", "Wednesday"};

统一的初始化

　　标准C++在类型初始化中存在一些问题。语言中存在几种类型初始化方式，但替换使用的话产生的结果不尽相同。传统的构造语法看起来更像函数声明。必须采取措施以使编译器不把对象构造误认为函数声明。只有集合类型和POD类型能用集合初始化器初始化（用SomeType var = {/*stuff*/};).

　　C++0x将提供一种能作用于任何对象的完全统一的类型初始化形式。这种形式对初始化列表语法作了扩展：

　　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式的初始化列表。每个public变量都将用初始化列表中的值初始化。如果需要，隐式类型转化将被使用，并且如果没有隐式类型转化可供使用，编译器将报告编译失败。

　　var2的初始化只是简单地调用构造器。

　　统一的初始化对象构造将消除在某些情况下指定类型的需要：

　　struct IdString

　　{

　　std::string name;

　　int identifier;

　　};

　　IdString var3{"SomeName", 4};

　　这种语法会自动使用const char *调用std::string进行初始化。程序员也可以使用下面的代码：

　　IdString GetString()

　　{

　　return {"SomeName", 4}; //注意，这里没写return ldString{"SomeName", 4}

　　}

　　统一的初始化形式不会取代构造器语法。某些情况下仍然需要构造器语法。如果一个类具有初始化列表构造器(TypeName(initializer_list);),，那么只要初始化列表符合该构造器的类型，初始化列表构造将优先于其他构造形式。

　　C++0x版本的std::vector将拥有匹配与模板参数的初始化列表构造器。这就意味着下面这段代码：

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

　　这段代码将调用初始化列表构造器，而不会调用std::vector中接受单个长度参数并创建相应长度的vector的构造器。为了调用后一个构造器，用户需要直接使用标准构造器语法。

类型推定

　　在标准的C++和C语言中，变量在使用时必须明确指定其类型。然而，随着模板类型及模板元编程的到来，表述某些定义完好的函数的返回值的类型变得不那么容易了。由此，在函数中存储中间值也变得困难，用户有可能需要了解某个模板元编程库的内部结构才行。

　　C++0x将通过两种方式来缓解这些困难。首先，带有明确初始化的变量定义将可以使用auto关键字。这种初始化将创建与初始化器类型相同的变量。

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

　　auto otherVariable = 5;

　　someStrangeCallableType的类型将等同于任何由boost::bind所返回的适合于这些特定参数的模板函数的类型。编译器很容易知道其类型，用户则不然。

　　otherVariable的类型也定义完好，但用户更容易推定其类型。该变量是整型，也就是整型常量的类型。

　　另外，关键字decltype可用于在编译期确定某个表达式的类型。比如：

　　int someInt;

　　decltype(someInt) otherIntegerVariable = 5;

　　这种用法相对于auto可能更有效，因为auto变量的类型只有编译器才知道。而且，对于那些大量使用操作符重载及特化类型的代码，使用decltype来推导表达式的类型也很有用。

　　auto在减少代码冗余性方面也很有用。比如，写下面这段代码时：

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

　　程序员可以使用下面这种更短的形式：

　　for (auto itr = myvec.begin(); itr != myvec.end(); ++itr)

　　当程序员在开始使用嵌套容器时，这两段代码的区别将更加明显，尽管在这种情况下使用typedef也是一种减少代码的好方法。

以范围为基础的 for 循环（for each）

　　C++库Boost定义了几个区间概念。区间代表了与容器相类似的列表中两点之间的可控列表。已序容器是区间的超集。已序容器中的两个迭代器也能定义一个区间。这些概念和算法都将被融入C++0x的标准库中。然而，C++0x还将提供一种专用的语言设施来运用区间概念。

　　for语句将使区间概念上的循环更容易：

　　int my_array[5] = { 1, 2, 3, 4, 5 };

　　for(int &x: my_array)

　　{

　　x *= 2;

　　}

　　新的for循环的第一部分定义了用于在区间上循环的变量。和普通for循环中声明的变量一样，该变量的作用域也仅限于循环之内。置于":"之后的第二部分则表示将进行循环的区间。在这种情况下，存在一个约束映射可以将C式数组转化为区间。

　　进行循环的区间还可以是std::vector，或任何符合区间概念的对象。

Lambda函数与Lambda表达式（内部函数）

　　在标准C++语言中，尤其在使用诸如sort和find之类的标准库算法函数时，用户总是希望在算法函数调用的触发点附近定义谓词函数。在这一方面语言中只有一种机制可供利用：在函数中定义类。通常这种做法既啰嗦又笨重。另外，标准C++语言不允许在函数中定义的类充当模板参数，所以这种做法行不通。

　　显而易见，解决方案在于允许定义lambda表达式和 lambda函数。C++0x将允许定义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被创建并用于存储中间值。和普通函数一样，中间值在多次函数调用之间不会被保存。

　　如果lambda函数不返回值，即返回值类型为void的话，该返回值类型也可完全省略。

　　在lambda函数作用域范围内被定义的变量的引用也能被使用。这些变量的合集通常被称为闭包。闭包可以定义并使用如下：

　　std::vector<int> someList;

　　int total = 0;

　　std::for_each(someList.begin(), someList.end(), [&total](int x) {

　　total += x

　　});

　　std::cout << total;

　　这段代码将显示列表中所有元素的总和。变量total将被存为该lambda函数相应的闭包的一部分。由于闭包变量total是栈变量total的引用，使用前者可以改变后者的值。

　　为栈变量生成的闭包变量也可以不用引用操作符/&/定义，这种情况下lambda函数将拷贝其值。这种做法将促使用户明确声明其意图：是引用栈变量还是拷贝栈变量。引用栈变量可能会产生危险。如果某个lambda函数将在所创建的作用域之外被引用（比如将此lambda函数存放在std::function（C++0x标准）对象中可以做到这一点），那么用户必须保证该lambda函数没有引用任何栈变量。

　　对于那些可以保证只在其所创建的作用域内被执行的lambda函数，使用栈变量无须通过显式引用：

　　std::vector<int> someList;

　　int total = 0;

　　std::for_each(someList.begin(), someList.end(), [&](int x) {

　　total += x

　　});

　　这种lambda函数的具体内部实现可能会有所不同，但可以预期这种lambda函数可能不会保存所有栈变量的引用而是会保存函数创建时的栈指针。

　　如果不用[&]而用[=]，那么所有被引用的变量都将被拷贝，从而允许lambda函数在原有变量生命期结束后仍然能够被使用。

　　缺省指示符还能和参数列表结合使用。比如，如果用户希望只拷贝其中一个变量的值，而对其他变量使用引用，则可使用下面的代码：

　　int total = 0;

　　int value = 5;

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

　　这段代码将导致total被存为引用，而value则会被存为拷贝。

　　如果一个lambda函数由一个类的某个成员函数定义，那么此lambda函数便被认定为该类的友元。这种lambda函数可以使用属于该类类型的对象的引用并访问其内部成员。

　　[](SomeType *typePtr) { typePtr->SomePrivateMemberFunction() };

　　只有当lambda函数在SomeType的某个成员函数中创建时这段代码才能工作。

　　对于指向当前成员函数所隶属对象的this指针，其处理有些特殊：必须在lambda函数中明确指定。

　　[this]() { this->SomePrivateMemberFunction() };

　　使用[&] 或 [=]形式将使this自动可用。

　　Lambda函数是一些类型取决于编译器的函数对象。它们的类型只对编译器开放。如果用户希望把lambda函数当作参数，那么要么参数相应类型为模板，要么创建一个std::function用于保存lambda函数。使用auto关键字则可以将lambda函数保存在局部变量中。

　　auto myLambdaFunc = [this]() {

　　this->SomePrivateMemberFunction()

　　};

　　然而，如果lambda函数的所有闭包变量均为引用,或者lambda函数根本没有闭包变量，那么所产生的函数对象将具有一种特殊类型：std::reference_closure。其中R(P)是带返回值的函数签名。这样做的理由在于期望此种类型的效率能好于使用std::function。

　　std::reference_closure<void()> myLambdaFunc = [this]() {

　　this->SomePrivateMemberFunction()

　　};

　　myLambdaFunc();

新增的函数语法

　　标准C语言的函数声明语法对于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相加所产生的类型。即使有了前面所讲述的C++0x的decltype功能，仍然不行：

　　template< typename LHS, typename RHS>

　　decltype(lhs+rhs) AddingFunc(const LHS &lhs, const RHS &rhs)

　　{

　　return lhs + rhs;

　　}

　　这一段并非合法的C++代码，因为lhs和rhs尚未定义，只有在词法分析器分析出函数原型的其余部分之后这两者才能成为有效的标识符。

　　为解决这一问题，C++0x将引入一种新型的函数定义和声明的语法：

　　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;

　　}

约束

　　在C++语言中，模板类和模板函数必须对它们所接受的类型施加某些限制。比如，STL容器要求容器中的类型必须可以赋值。与类继承所展示的动多态（任何能接受Foo&类型对象作为参数的函数也能传入Foo的子类型）有所不同，任何类只要支持某个模板所使用的操作，它就能被用于该模板。在函数传参数的情况下，参数所必须满足的需求是清晰的（必须是Foo的子类型），而模板的场合下，对象所需满足的接口则是隐含在模板实现当中的。约束则提供了一种将模板参数所必需满足的接口代码化的机制。

　　引入约束的最初动因在于改进编译错误信息的质量。如果程序员试图使用一种不能提供某个模板所需接口的类型，那么编译器将产生错误信息。然而，这些错误信息通常难以理解，尤其对于新手而言。首先，错误信息中的模板参数通常被完整拼写出来，这将导致异常庞大的错误信息。在某些编译器上，简单的错误会产生好几K的错误信息。其次，这些错误信息通常不会指向错误的实际发生地点。比如，如果程序员试图创建一个其成员为不具备拷贝构造器对象的vector，首先出现的错误信息几乎总是指向vector类中试图拷贝构造其成员的那段代码。程序员必须具备足够的经验和能力才能判断出实际的错误在于相应类型无法完全满足vector所需要的接口。

　　在试图解决此问题的过程中，C++0x为语言添加了约束这一特性。与OOP使用基类来限制类型的功能相似，约束是一种限制类型接口的具名结构。而与OOP所不同的是，约束定义并非总是与传入模板的参数类型明确相关，但它总是与模板定义相关：

　　template < LessThanComparable T >

　　const T & min(const T & x, const T & y)

　　{

　　return y < x ? y : x;

　　}

　　这里没有用/class /或/ typename/将模板参数指定为任意类型，而是使用了/LessThanComparable/这个之前定义的约束。如果某个传入/min/模板参数的类型不符合/LessThanComparable/约束的定义，那么编译器将报告编译错误，告诉用户用来具现化该模板的类型不符合/LessThanComparable/约束。

　　下面是一个更一般化的约束形式：

　　template<typename T> requires LessThanComparable<T>

　　const T& min(const T &x, const T &y)

　　{

　　return y < x ? y : x;

　　}

　　关键字/requires/之后为一串约束的声明。它可以被用于表述涉及多个类型的约束。此外，如果用户希望当类型匹配该约束时不要使用某个特定模板，也可以用/requires !LessThanComparable/。可以像模板特化那样使用这种机制。一个通用模板可能通过显式禁用一些特性丰富的约束来处理具有较少特性的类型。而这些约束则可通过特化利用某些特性来取得更高的效率并实现更多的功能。

　　约束定义如下：

　　auto concept LessThanComparable < typename T >

　　{

　　bool operator<(T, T);

　　}

　　这个例子中的关键字/auto/意味着任何类型只要支持约束中所指定的操作便被认定支持该约束。如果不使用/auto/关键字，为声明某个类型支持该约束就必须对该类型使用约束映射。

　　该约束声明任何类型只要定义了接受两个参数并返回bool型的<操作符就被认为是/LessThanComparable/。该操作符不一定是一个自由函数，它也可以是T类型的成员函数。

　　约束也可以涉及多个类型。比如，约束能表示一个类型可以转换为另一个类型：

　　auto concept Convertible < typename T, typename U >

　　{

　　operator U(const T &);

　　}

　　为了在模板中使用这个约束，模板必须使用一种更为一般化的形式：

　　template < typename U, typename T >

　　requires Convertible < T, U > U convert(const T & t)

　　{

　　return t;

　　}

　　约束可以组合运用。比如，给定一个名为/Regular/的约束

　　concept InputIterator < typename Iter, typename Value >

　　{

　　requires Regular < Iter >;

　　Value operator*(const Iter &);

　　Iter & operator++(Iter &);

　　Iter operator++(Iter &, int);

　　}

　　/InputIterator/约束的第一个模板参数必须符合/Regular/约束。

　　与继承相似，约束也可派生自另一约束。与类继承相似，满足派生约束所有限制条件的类型必须满足基本约束的所有限制条件。约束派生定义形同类派生：

　　concept ForwardIterator<typename Iter, typename Value> :

　　InputIterator<Iter, Value>

　　{

　　//Add other requirements here.

　　}

　　类型名可以与约束相关。这将施加一些限制条件：在使用这些约束的模板中，这些类型名可供使用：

　　concept InputIterator < typename Iter >

　　{

　　typename value_type;

　　typename reference;

　　typename pointer;

　　typename difference_type;

　　requires Regular < Iter >;

　　requires Convertible < reference, value_type >;

　　reference operator*(const Iter &); // dereference

　　Iter & operator++(Iter &); // pre-increment

　　Iter operator++(Iter &, int); // post-increment

　　// ...

　　}

　　约束映射允许某些类型被显式绑定到某个约束。如有可能，约束映射也允许在不改变类型定义的前提下让该类型采用某个约束的语法。比如下例：

　　concept_map InputIterator < char *>

　　{

　　typedef char value_type;

　　typedef char &reference;

　　typedef char *pointer;

　　typedef std::ptrdiff_t difference_type;

　　};

　　这个约束映射填补了当/InputIterator/映射作用于/char*/类型时所需要的类型名。

　　为增加灵活性，约束映射本身也能被模板化。上例可以被延伸至所有指针类型：

　　template < typename T > concept_map InputIterator < T * >

　　{

　　typedef T value_type;

　　typedef T & reference;

　　typedef T *pointer;

　　typedef std::ptrdiff_t difference_type;

　　};

　　此外，约束映射也可充当迷你类型，此时它会包含函数定义以及其他与类相关的结

　　构设施：

　　concept Stack < typename X >

　　{

　　typename value_type;

　　void push(X &, const value_type &);

　　void pop(X &);

　　value_type top(const X &);

　　bool empty(const X &);

　　};

　　template < typename T > concept_map Stack < std::vector < T > >

　　{

　　typedef T value_type;

　　void push(std::vector < T > &v, const T & x)

　　{

　　v.push_back(x);

　　}

　　void pop(std::vector < T > &v)

　　{

　　v.pop_back();

　　}

　　T top(const std::vector < T > &v)

　　{

　　return v.back();

　　}

　　bool empty(const std::vector < T > &v)

　　{

　　return v.empty();

　　}

　　};

　　这个约束映射将允许任何接受实现了/Stack/约束的类型的模板也接受

　　/std::vector/,同时将所有函数调用映射为对/std::vector/的调用。最终，这种

　　做法将允许一个已经存在的对象在不改变其定义的前提下，转换其接口并为模板函

　　数所利用。

　　最后需要指出的是，某些限制条件可以通过静态断言来检测。这种手段可以用来检

　　测那些模板需要但却面向其他方面问题的限制条件。

对象构建方面的改进

　　在标准C++语言中，构造器不能调用其他构造器。每个构造器要么独自构建类的所有成员要么调用某个公共成员函数。基类的构造器不能直接暴露给派生类：即便基类的构造器更合适，子类也必须实现自己的构造器。类的非静态数据成员不能在其声明的场所初始化，它们只能在构造器中初始化。

　　C++0x将为所有这些问题提供解决方案。

　　C++0x将允许构造器调用其他伙伴构造器（被称为委托）。如此，只需添加少量代码，构造器便能利用其他构造器的行为。另外一些语言,比如Java和C#，允许这样做。语法如下：

　　class SomeType

　　{

　　int number;

　　public:

　　SomeType(int newNumber):number(newNumber) {}

　　SomeType():SomeType(42) {}

　　};

　　这就产生了一个问题：C++03认为一个对象在其构造器执行完毕时才能构建完成，而C++0x则认为一个对象在任何构造器执行完毕时都将构建完成。由于多个构造器被允许执行，这将导致每个委托构造器都可能在一个已经构造完成的对象上执行操作。派生类构造器将在基类的所有委托构造器执行完毕后执行。

　　关于基类构造器，C++0x将允许一个类指定需要继承的基类构造器。这意味着C++0x编译器将产生代码用于类继承，即将子类构造转发为基类构造。注意这是一个要么全部要么没有的特性：或者全部构造器被转发，或者没有构造器被转发。另外注意在多重继承的情况下有些限制，比如类构造器不能继承来自两个类的具有相同签名的构造器。同时子类构造器的签名也不能与用来继承的基类构造器相匹配。

　　相应语法如下：

　　class BaseClass

　　{

　　public:

　　BaseClass(int iValue);

　　};

　　class DerivedClass:public BaseClass

　　{

　　public:

　　using default BaseClass;

　　};

　　关于成员初始化，C++0x将允许以下语法：

　　class SomeClass

　　{

　　public:

　　SomeClass() {}

　　explicit SomeClass(int iNewValue):iValue(iNewValue) {}

　　private:

　　int iValue = 5;

　　};

　　该类的任何构造器都将把iValue初始化为5，除非它提供自己的实现来改变这种行

　　为。所以上面的空构造器将按照类的定义来初始化iValue，而接受int的构造器则

　　会用给定的参数来初始化iValue。

空指针

　　在现行标准中，常量0既是常量整数又是空指针，充当着双重角色。这一行为自1972年C语言早期以来便一直存在。

　　多年来，程序员为了避免这种语义模糊多采用标识符NULL来代替0。然而，两项C++语言的设计选择集中产生了另一项语义模糊。在C语言中，NULL作为预编译宏被定义为((void*)0)或0。在C++语言中，void*不能隐式转换为其他指针类型，因而在前项定义下，简单如char* c = NULL的代码会通不过编译。为解决此问题，C++确保NULL展开为0，并作为一种特例允许其转换为其他指针类型。这一选择在同重载机制交互时产生了麻烦。比如，假设程序中存在以下声明：

　　void foo(char *);

　　void foo(int);

　　现在调用foo(NULL)，则foo(int)版本将会被调用，几乎可以肯定这不是程序员的意图。

　　新标准很可能引入一个专用于空指针的关键字，目前nullptr承担这一角色。

　　nullptr不能被赋给整型，也不能与整型相比较，但它可以向其他指针类型赋值并与之比较。

　　0的现存角色将会因显而易见的兼容性理由而得到保留。

　　如果新的语法取得成功，C++委员会可能会将把0和NULL当作空指针的做法标记为已废弃特性，并最终废弃这种双重角色。

强类型枚举

　　在标准C++语言中，枚举不是类型安全的。枚举值实际上就是整数，即便其枚举类型各不相同。这样不同枚举类型的两个枚举值相互比较就成为可能。这方面C++03所提供的唯一安全特性为：一个整数或一种枚举类型的值不能隐式转换为其他枚举类型的值。另外，枚举所使用的整形的大小无法由用户指定，而只能由实现定义。最后，枚举值的作用域为枚举的外围作用域。这就意味着两个不同的枚举不能包含名字相同的成员。

　　C++0x将允许创建一类没有上述问题的特殊枚举。这种枚举通过enum class来声明：

　　enum class Enumeration

　　{

　　Val1,

　　Val2,

　　Val3 = 100,

　　Val4 /* = 101 */,

　　};

　　这种枚举是类型安全的。枚举类的值不会被隐式转换为整数，这样它们也不会被拿来与整数相比较。（Enumeration::Val4 == 101会产生编译错误）

　　枚举类所使用的类型可以明确指定。缺省情况下，如同上例，为int。但这也能像下例那样改变：

　　enum class Enum2 : unsigned int {Val1, Val2};

　　这种枚举的作用域也被指定为枚举类名的作用域。使用这种枚举名必须显式指定作用域。Val1无定义，而Enum2::Val1有定义。

　　另外，C++0x也将允许标准枚举提供其作用域范围以及其使用的整型大小。

　　enum Enum3 : unsigned long {Val1 = 1, Val2};

　　这种枚举名被定义具有枚举类型作用域，如(Enum3::Val1)。但是，为了保持向后兼容，枚举名也被放入外围作用域。

　　枚举的前置声明在C++0x中也将成为可能。以前，枚举类型不能前置声明的理由是枚举的大小取决于其内容。只要枚举值的大小在程序中得以指定，枚举就能前置声明。

　　enum Enum1; //在C++和C++0x均合法，未明确标明枚举数大小

　　enum Enum2 : unsigned int; //仅C++0x合法

　　enum class Enum3; //在C++0x中合法，枚举数被隐式确定为int型

　　enum class Enum4: unsigned int; //在C++0x中合法

　　enum Enum2 : unsigned short; //不合法，Enum2已被定义为不同类型

尖括号

　　标准C++的词法分析器在任何场合下都将">>"解释为右移操作符。然而，在模板定义中，如此解释两个右尖括号几乎总是错误的。

　　C++0x将改变词法分析器的规范以便在合理的情况下能把多个右尖括号解释为模板参数列表的结束符。可以用小括号来改变这种行为。

　　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++0x 表示式， (1>2) 被转换为 bool 类型值 false

显式转换操作符

　　标准C++为构造器添加了explicit关键字作为修饰符以防止只有单个参数的构造器使用隐式转换操作。然而，这种做法对于真正的转换操作符是无效的。比如，一个智能指针类可能有一个bool()操作符以使自身的行为更像原生指针。如果它包含这种转换操作，它就能用if(smart_ptr_variable)来测试。（若指针非空则测试是为真，否则测试为假。）然而，这种操作也会导致其他出乎意料的转换。由于C++的bool被定义为一种算术类型，这种指针也就可以被隐式转换为整型甚而浮点类型，从而导致一些用户并不希望出现的算术操作。

　　在C++0x中，explicit关键字将能用于转换操作符的定义中。与构造器一样，它将防止进一步的隐式转换。

模板的别名

　　在进入这个主题之前，各位应该先弄清楚“模板”和“类型”本质上的不同。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++0x 将会增加以下的语法：

　　template<typename first, typename second, int third>

　　class SomeType;

　　template<typename second>

　　using TypedefName = SomeType<OtherType, second, 5>;

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

　　typedef void(*PFD)(double);// 传统语法

　　using PF = void (*)(double); // 新增语法

无限制的union

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

　　以下为 C++0x 中 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++0x

　　};

　　这一改变仅放宽 union 的使用限制，不会影响既有的旧代码。

核心语言能力的提升

变长参数模板

　　在 C++0x 之前, 不论是模板类或是模板函数，都只能按其被声明时所指定的样子，接受一组固定数目的模板实参； C++0x 加入新的表示法，允许任意个数、任意类别的模板实参，不必在定义时将实参的个数固定。

　　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++0x 除了能定义类别安全的变长参数函数外，还能让类似 printf 的函数能自然地处理非自带类别的对象。 除了在模板实参中能使用...表示不定长模板实参外，函数实参也使用同样的表示法代表不定长实参。

　　template<typename... Params>

　　void printf(const std::string& strFormat, Params... parameters);

　　其中，Params 与 parameters 分别代表模板与函数的变长参数集合， 称之为实参包 (parameter pack)。实参包必须要和运算符“...”搭配使用，避免语法上的歧义。

　　变长参数模板中，变长参数包无法如同一般实参在类或函数中使用； 因此典型的手法是以递归的方法取出可用实参。

新的字符串常量

　　标准C++提供两种字符串常量。第一种，包含在双引号之间，生成一个以'\0'结尾的const char类型的数组。第二种，形为L""，生成一个以L'\0'结尾的const wchar_t类型的数组。这里wchar_t为宽字符。这两种字符串常量均没有对Unicode编码的字符串提供支持。

　　为了改进C++编译器对Unicode的支持，char类型的定义被修改成除了包含编译器基本执行字符集的所有成员之外还将至少包括UTF-8中的8位编码。以前它只包含前者。

　　C++0x将包括三种Unicode编码的字符串分别用于支持UTF-8，UTF-16，及 UTF-32。

用户自定义字面值

　　标准C++提供了数种字面值。字符"12.5"是能够被编译器解释为数值12.5的double类别字面值。然而，加上"f"的后置，像是"12.5f"，则会产生数值为12.5的float类别字面值。在C++规范中字面值的后置是固定的，而且C++代码并不允许创立新的字面后置。

　　C++1x (?)开放用户定义新的字面修饰符(literal modifier)，利用自定义的修饰符完成由字面值建构对象。

　　字面值转换可以区分为两个阶段：转换前与转换后 (raw 与 cooked)。 转换前的字面值指特定字符串行，而转换后的字面值则代表另一种类别。 如字面值1234，转换前的字面值代表 '1', '2', '3', '4' 的字符串行； 而转换后，字面值代表整数值1234。 另外，字面值0xA转换前是串行'0', 'x', 'A'；转换后代表整数值 10。

多任务内存模型

　　C++标准委员会计划为多线程提供标准化支持。

　　有两部分将被涉及：对允许多线程在同一个程序中共存的内存模型提供定义，对这些线程间的交互提供支持。后者将通过类设施来实现。

　　内存模型对于描述多个线程在何种情况下可以访问相同的内存地址是不可或缺的。

　　一个遵守相应规则的程序可以保证运行正常，而一个破坏相应规则的程序则可能会因为编译器的优化行为以及内存一致性等问题而出现不可预料的行为。

线程局部存储

　　在多线程环境下，每个线程通常都拥有一些自己所独有的变量。对于函数的局部变量来说确实如此，而对于全局以及静态变量来说就不是这样。

　　除了现存的静态，动态以及自动存储方式以外，在下一个标准中还将提议增加一种局部于线程的存储方式。线程局部存储方式将通过thread_local存储指示符来指定。

　　一个本来可能具有静态存储方式的对象（即生命期跨越程序整个执行过程的对象）现在可能会被赋予线程存储方式。与静态存储的对象相似，线程局部的对象应该也能用构造器构建并用析构器销毁。

关于缺省成员函数

　　显式使用/不使用C++类的某些（缺省）成员函数在标准C++语言中，如果对象自己不提供，编译器会自动产生一个缺省构造器，一个拷贝构造器，一个拷贝赋值运算符operator=，以及一个析构器。如前所述，用户可以通过提供自己的版本来覆盖这些缺省实现。C++还定义了一些能作用于所有类的全局操作符（如operator=和operator new），当然用户也能覆盖其实现。

　　问题在于用户对于这些默认产生的函数缺乏控制。例如，如果需要使某个类不可拷贝，用户需要声明一个私有的拷贝构造器，一个拷贝赋值运算符，同时略去这些函数的定义。试图使用这些函数将产生编译错误或链接错误。然而这不是一个理想的解决方案。

　　而且，对于缺省构造器而言，明确告诉编译器产生这类函数通常非常有用。如果对象已经具有了任何构造器，编译器就不会为它提供缺省构造器。这在许多场合下的确有用，但有时也需要同时拥有一个编译器产生的缺省构造器以及另一个专用构造器。

　　C++0x将允许用户明确指定使用或不使用这些标准的对象函数。比如，下面这个类型明确声明它会使用缺省构造器。

　　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;

　　};

　　这个对象只能在栈里面分配或成为其他类型的成员。不使用不可移植的手段将无法在堆中分配该对象。由于使用就地分配new操作符是调用构造器在用户所分配的内存中创建对象的唯一途径，并且这一途径已经被上述代码所禁止，可以肯定对象将无法被适当创建。

　　指示符= delete可被用于禁止调用任意函数，当然它也能用于禁止调用具有某些特定参数的成员函数。比如：

　　struct NoDouble

　　{

　　void f(int i);

　　void f(double) = delete;

　　};

　　编译器将会拒绝用double值调用f()的企图，而不会无声无息地将其转换为int。这种方法可以被一般化从而禁止使用int以外的任何类型调用该函数，代码如下：

　　struct OnlyInt

　　{

　　void f(int i);

　　template<class T> void f(T) = delete;

　　};

long long int类型

　　在32位系统中，存在一种至少64位的long long整数类型十分有用。C99标准将此类型引入标准C，大多数C++编译器也早就将它作为一种扩展。事实上，一些编译器在C99引入它很久之前就已经提供支持。C++0x将把这种类型加入标准C++。

静态断言

　　C++提供两种方式测试断言，宏assert以及预编译命令#error，但是这两者对于模版来说都不合用。宏在运行期测试断言，而预编译命令则在预编译期测试断言，这时候模版还未能实例化。所以它们都不适合来测试牵扯到模板实参的相关特性。

　　新的机能会引进新的方式可以在编译期测试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!");

　　};

sizeof操作符的改变

　　允许在没有提供类实例的前提下作用于类的成员，无需明确的对象。

　　在标准C++，sizeof可以作用在对象以及类别上。但是不能够做以下的事：

　　struct SomeType { OtherType member;};sizeof(SomeType::member);// 直接由SomeType型别取得非静态成员的大小

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

透明的垃圾收集

　　C++0x不会直接提供透明垃圾收集机制。作为替代，C++0x标准将包含一些有利于在C++实现垃圾收集机制的特性。

　　对垃圾收集机制的完全支持将会延迟到标准的下一个版本，或者是一个技术报告。