C++11语言扩展：常规特性

ゞ浴缸里的玫瑰 2022-09-20 11:23 175阅读 0赞

原文链接：  [isocpp][]    翻译：  [伯乐在线 ][Link 1] \-  [christian][]  
译文链接：  [http://blog.jobbole.com/55063/][http_blog.jobbole.com_55063]

\[ 转载必须在正文中标注并保留原文链接、译文链接和译者等信息。\]

本节内容：auto、decltype、基于范围的for语句、初始化列表、统一初始化语法和语义、右值引用和移动语义、Lambdas、noexcept防止抛出异常、constexpr、nullptr——一个指针空值常量、复制并再抛出异常、内联命名空间、用户自定义数据标识。

auto

推导

auto x = 7;

在这里因为它的初始化类型我们将得到x的int类型。一般来说，我们可以写

auto x = expression;

x的类型我们将会根据初始化表达式“ expression”的类型来自动推导。

当一个变量的类型很难准确的知道或者写出的时候，用atuo通过初始化表达式的类型进行推导显然是非常有用的。

参考：

template<class T> void printall(const vector<T>& v)
    {
        for (auto p = v.begin(); p!=v.end(); ++p)
            cout << *p << "\n";
    }

在C++98里我们必须这样写

template<class T> void printall(const vector<T>& v)
       {
           for (typename vector<T>::const_iterator p = v.begin(); p!=v.end(); ++p)
               cout << *p << "\n";
       }

当一个变量的类型取决于模板实参的时候不用auto真的很难定义，例如：

template<class T, class U> void multiply(const vector<T>& vt, const vector<U>& vu)
        {
            // ...
            auto tmp = vt[i]*vu[i];
            // ...
        }

从T\*U的表达式，我们人类的思维是很难理清tmp的类型的，但是编译器肯定知道T和U经过了什么特殊处理。

auto的特性在最早提出和应用时是有区别的：1984年初，Stroustrup在他的Cfront实现里用到了它，但是是由于C的兼容问题被迫拿来用的，这些兼容的问题已经在C++98和C++99接受了隐性int时候消失了。也就是说，现在这两种语言要求每一个变量和函数都要有一个明确的类型定义。auto旧的含义（即这是一个局部变量）现在是违法的。标准委员会的成员们在数百万行代码中仅仅只找到几百个用到auto关键字的地方，并且大多数出现在测试代码中，有的甚至就是一个bug。

auto在代码中主要是作为简化工具，并不会影响标准库规范。

参考：

*  the C++ draft section 7.1.6.2, 7.1.6.4, 8.3.5 (for return types)
 *  \[N1984=06-0054\] Jaakko Jarvi, Bjarne Stroustrup, and Gabriel Dos Reis: [Deducing the type of variable from its initializer expression (revision 4)][Deducing the type of variable from its initializer expression _revision 4].
 *  Herb Sutter: [GotW \#92: Auto Variables, Part 1][GotW _92_ Auto Variables_ Part 1]
 *  Herb Sutter: [GotW \#93: Auto Variables, Part 2][GotW _93_ Auto Variables_ Part 2]
 *  Herb Sutter: [GotW \#94: AAA Style (Almost Always Auto)][GotW _94_ AAA Style _Almost Always Auto]

decltype

decltype(E)的类型(“声明类型”)可用名称或表达E来声明。例如：

void f(const vector<int>& a, vector<float>& b)
      {
          typedef decltype(a[0]*b[0]) Tmp;
          for (int i=0; i<b.size(); ++i) {
              Tmp* p = new Tmp(a[i]*b[i]);
              // ...
          }
          // ...
      }

这个概念已经流行在泛型编程的标签“typeof”很长一段时间,但实际使用的“领域”的实现是不完整和不兼容,所以标准版命名了decltype。

注意:喜欢使用auto时,你只是需要一个变量的类型初始化。你真的需要decltype如果你需要一个类型的东西不是一个变量,例如返回类型。

参考：

*  the C++ draft 7.1.6.2 Simple type specifiers
 *  \[Str02\] Bjarne Stroustrup. Draft proposal for “typeof”. C++ reflector message c++std-ext-5364, October 2002. (original suggestion).
 *  \[N1478=03-0061\] Jaakko Jarvi, Bjarne Stroustrup, Douglas Gregor, and Jeremy Siek: [Decltype and auto][] (original proposal).
 *  \[N2343=07-0203\] Jaakko Jarvi, Bjarne Stroustrup, and Gabriel Dos Reis: [Decltype (revision 7): proposed wording][Decltype _revision 7_ proposed wording].

基于范围的for循环

声明的范围像是STL-sequence定义的begin()和end()，允许你在这个范围内循环迭代。所有标准容器可以作为一个范围来使用，比如可以是std::string,初始化器列表,一个数组,和任何你可以定义begin()和end()的，比如istream。例如：

void f(vector<double>& v)
    {
        for (auto x : v) cout << x << '\n';
        for (auto& x : v) ++x;  // using a reference to allow us to change the value
    }

你可以看到，V中所有的元素都从begin()开始迭代循环到了end()。另一个例子:

for (const auto x : { 1,2,3,5,8,13,21,34 }) cout << x << '\n';

begin()(和end())可以被做为x.begin()的成员或一个独立的函数被称为开始(x)。成员版本优先。

参考：

*  the C++ draft section 6.5.4 (note: changed not to use concepts)
 *  \[N2243==07-0103\] Thorsten Ottosen: [Wording for range-based for-loop (revision 2)][Wording for range-based for-loop _revision 2].
 *  \[N3257=11-0027 \] Jonathan Wakely and Bjarne Stroustrup: [Range-based for statements and ADL][] (Option 5 was chosen).

初始化列表

推导

vector<double> v = { 1, 2, 3.456, 99.99 };
       list<pair<string,string>> languages = {
           {"Nygaard","Simula"}, {"Richards","BCPL"}, {"Ritchie","C"}
       }; 
       map<vector<string>,vector<int>> years = {
           { {"Maurice","Vincent", "Wilkes"},{1913, 1945, 1951, 1967, 2000} },
           { {"Martin", "Ritchards"}, {1982, 2003, 2007} }, 
           { {"David", "John", "Wheeler"}, {1927, 1947, 1951, 2004} }
       };

初始化列表不再只针对于数组了。定义一个接受｛｝初始化列表的函数（通常是初始化函数）接受一个std::initializer\_list < T >的参数类型，例如：

void f(initializer_list<int>);
    f({1,2});
    f({23,345,4567,56789});
    f({});  // the empty list
    f{1,2}; // error: function call ( ) missing
    years.insert({
       {"Bjarne","Stroustrup"},{1950, 1975, 1985}});

初始化器列表可以是任意长度的,但必须同种类型的(所有元素必须的模板参数类型,T,或可转换T)。

一个容器可能实现一个初始化列表构造函数如下：

template<class E> class vector {
      public:
          vector (std::initializer_list<E> s) // initializer-list constructor
          {
                  reserve(s.size());  // get the right amount of space
                  uninitialized_copy(s.begin(), s.end(), elem);   // initialize elements (in elem[0:s.size()))
              sz = s.size();  // set vector size
          }
          // ... as before ...
      };

直接初始化和复制初始化的区别是对初始化列表的维护，但是因为初始化列表的相关联的频率就降低了。例如std::vector有一个int类型显示构造函数和initializer\_list构造函数：

vector<double> v1(7);   // ok: v1 has 7 elements
       v1 = 9;                 // error: no conversion from int to vector
       vector<double> v2 = 9;  // error: no conversion from int to vector
       void f(const vector<double>&);
       f(9);                           // error: no conversion from int to vector
       vector<double> v1{7};           // ok: v1 has 1 element (with its value 7.0)
       v1 = {9};                       // ok v1 now has 1 element (with its value 9.0)
       vector<double> v2 = {9};        // ok: v2 has 1 element (with its value 9.0)
       f({9});                         // ok: f is called with the list { 9 }
       vector<vector<double>> vs = {
           vector<double>(10),         // ok: explicit construction (10 elements)
           vector<double>{10},         // ok explicit construction (1 element with the value 10.0)
           10                          // error: vector's constructor is explicit
       };

函数可以作为一个不可变的序列访问initializer\_list。例如：

void f(initializer_list<int> args)
        {
            for (auto p=args.begin(); p!=args.end(); ++p) cout << *p << "\n";
        }

仅具有一个std::initializer\_list的单参数构造函数被称为初始化列表构造函数。

标准库容器，string类型及正则表达式均具有初始化列表构造函数，以及（初始化列表）赋值函数等。一个初始化列表可被用作Range，例如，表达式Range。

初始化列表是一致泛化初始化解决方案的一部分。他们还防止类型收窄。一般来说,你应该通常更喜欢使用\{ \}来代替()初始化,除非你想用c++98编译器来分享代码或(很少)需要使用()调用没initializer\_list重载构造函数。

参考：

*  the C++ draft 8.5.4 List-initialization \[dcl.init.list\]
 *  \[N1890=05-0150 \] Bjarne Stroustrup and Gabriel Dos Reis: [Initialization and initializers][] (an overview of initialization-related problems with suggested solutions).
 *  \[N1919=05-0179\] Bjarne Stroustrup and Gabriel Dos Reis: [Initializer lists][].
 *  \[N2215=07-0075\] Bjarne Stroustrup and Gabriel Dos Reis: [Initializer lists (Rev. 3)][Initializer lists _Rev. 3].
 *  \[N2640=08-0150\] Jason Merrill and Daveed Vandevoorde: [Initializer Lists – Alternative Mechanism and Rationale (v. 2)][Initializer Lists _ Alternative Mechanism and Rationale _v. 2] (final proposal).

统一初始化语法和语义

c++ 98提供了几种方法初始化一个对象根据其类型和初始环境。滥用时,会产生可以令人惊讶的错误和模糊的错误消息。推导：

tring a[] = { "foo", " bar" };          // ok: initialize array variable
      vector<string> v = { "foo", " bar" };    // error: initializer list for non-aggregate vector
      void f(string a[]);
      f( { "foo", " bar" } );                  // syntax error: block as argument

和

int a = 2;              // "assignment style"
    int aa[] = { 2, 3 };    // assignment style with list
    complex z(1,2);         // "functional style" initialization
    x = Ptr(y);             // "functional style" for conversion/cast/construction

和

int a(1);   // variable definition
    int b();    // function declaration
    int b(foo); // variable definition or function declaration

要记得初始化的规则并选择最好的方法去初始化是比较难的。

C++11的解决方法是允许所有的初始化使用初始化列表

X x1 = X{1,2}; 
     X x2 = {1,2};   // the = is optional
     X x3{1,2}; 
     X* p = new X{1,2}; 
     struct D : X {
         D(int x, int y) :X{x,y} { /* ... */ };
     };
     struct S {
         int a[3];
         S(int x, int y, int z) :a{x,y,z} { /* ... */ }; // solution to old problem
     };

重点是，x\{a\}在在执行代码中都创建了一个相同的值，所以在使用“｛｝”进行初始化合法的情况下都产生了相同的结果。例如：

X x{a}; 
     X* p = new X{a};
     z = X{a};         // use as cast
     f({a});           // function argument (of type X)
     return {a};       // function return value (function returning X)

[isocpp]: http://isocpp.org/wiki/faq/cpp11-language
[Link 1]: http://blog.jobbole.com/
[christian]: http://blog.jobbole.com/author/christian/
[http_blog.jobbole.com_55063]: http://blog.jobbole.com/55063/
[Deducing the type of variable from its initializer expression _revision 4]: http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2006/n1984.pdf
[GotW _92_ Auto Variables_ Part 1]: http://herbsutter.com/2013/06/07/gotw-92-solution-auto-variables-part-1/
[GotW _93_ Auto Variables_ Part 2]: http://herbsutter.com/2013/06/13/gotw-93-solution-auto-variables-part-2/
[GotW _94_ AAA Style _Almost Always Auto]: http://herbsutter.com/2013/08/12/gotw-94-solution-aaa-style-almost-always-auto/
[Decltype and auto]: http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2003/n1478.pdf
[Decltype _revision 7_ proposed wording]: http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2343.pdf
[Wording for range-based for-loop _revision 2]: http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2243.html
[Range-based for statements and ADL]: http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2011/n3257.pdf
[Initialization and initializers]: http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2005/n1890.pdf
[Initializer lists]: http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2005/n1919.pdf
[Initializer lists _Rev. 3]: http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2215.pdf
[Initializer Lists _ Alternative Mechanism and Rationale _v. 2]: http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2640.pdf