[GeekBand] 探讨C++新标准之新语法——C++ 11~14

一、 可变参数模板（Variadic Templates）

在C++11中，出现了参数数目可变的模板，这部分在之前C++高级编程的时候就有学习到。

其实，在C中就有类似的设定。最常用的printf()，就是一个采用了一个…类型的可变参数。…类型的参数代表是一个参数组。

1. int   sumi(int   c,   ...)
     {
       va_list   ap;
2.     va_start(ap,  c);
3.     int   i;
4.     int   sum   =   c;
5.     c   =   va_arg(ap,  int);
6.     while  (0  !=  c)
         {
7.         sum   =   sum  +  c;
8.         c   =   va_arg(ap,  int);
9.     }
10.     return   sum;
      }

    在C中的…参数可以用va_list，va_start，va_arg等宏定义进行操作，其中va_arg()代表取值并进行指针的偏移；这种方式要求参数的类型必须能够得知。对于上例，即给定了参数就是int型；对于printf，则是通过一个字符串参数确定了有多少个变量。

    那么在C++中的…称为Pack(包)；正如之前在高级编程时介绍的一样，通常采用递归的方式进行参数调用。

11. void print() {}  
12. template < typename T, typename… Types > void print(const T & firstArg,  
13.     const Types & …args) {  
14.     cout << firstArg << endll;  
15.     print(args…);  
16. }  

    在这里和之前版本的Package不同，非常神奇的一点是，我们不再需要使用偏移量。也就是说，我们在使用的时候根本不需要知道Pack里边的参数类型是什么。

    在C++11中提出了一个新的数据类型tuple（元祖），就是利用了新的…实现的：

17.  
18. template < typename Head, typename...Tail > class tuple < Head, Tail... > : private tuple < Tail... > {  
19.     typedef tuple < Tail... > inherited;  
20.     public: 
21. tuple() {}  
22.     tuple(Head, Tail...vtail): m_head(v), inherited(vtail...) {}  //看第二行，inherited(vtail…)实际上是初始化父类对象
23.     typename Head head() {  
24.         return m_head;  
25.     }  
26.     inherited & tail() {  
27.         return *this;  
28.     }  //这个地方充分利用了递归继承的关系，只要指向自己的指针转型为指向自己父类的指针，那么就可以得到尾部（因为尾部就是当前对象的父类对象）
29.     protected: 
30. Head m_head;  
31. };  

    这个用法又非常的巧妙，Tuple继承自比自己少了Head参数的Tuple；称之为递归继承关系，如下图中的类图：

    

    提出几个原则，适用于…的使用：

    1. <T a,Types… b>比<Types… a>更特化；同时存在时，<Types… a>永远不会被调用；

    2. 注意递归的使用方法，例如求一组数据的最大值，就可以采用

32. int  maximum(int  n,  types…  args)  {        
33.     return  max(x,  maximum(args…))    
34. };    

    3.可以通过给模板参数加变量成员(即<int X,typename Y>这种类型)如int来进行计数，可以知道处理到了什么位置。

    4. 可以使用递归继承和递归组合的方式。

    二、 两个新的关键字nullptr & auto

    1. nullptr

    nullptr对象是一个空的指针，类型是nullptr_t；在C++11之前，一直是使用0（NULL就是0的一种宏定义）来代表空指针。在C++11中引入了nullptr，这一方面提高了代码可读性，另一方面使fun（int）和fun（void*）这种重载成为可能；

    2. auto

    自动推导返回值类型，编译器本身是有类型检查的功能的。C++11的auto就是在类型检查的时候才决定到底是什么类型，而不是像之前的编译器，检查左右是否一致。

    建议是指使用在类型特别长或者特别难写的情况，否则会降低可读性。

    还有一种情况是lambda表达式经常使用auto关键字

35. auto  I  =   [](int  x)->  bool  {  /*…*/ }    

    三、 初始化列表

    1.通用初始化方法

    在之前，初始化的时候如果调用构造函数，则要使用小括号；如果是创建对象数组，则要使用大括号。而在C++11中，我们可以使用大括号进行所有的初始化操作，包括诸如int values[] {1,2,3}及complex<double> c{4,3} [等价于c(4,3)].其内部时进行了一个Initializer List的转化，关于initializer list的信息见下一节。

    必须提出的是，作为数组进行初始化时，大括号中的参数是一个一个传给变量进行初始化的，并不能提供多个的初始化。

    2.std::initializer_list<>

36. #include < iostream > 
37. #include < stdio.h > 
38. #include < algorithm > 
39. #include < functional > 
40. using namespace std;  
41. class Print: public binary_function <  
42.     const char * , int, void > {  
43.         public: void operator()(const char * p, int a) const {  
44.             cout << a << ' ';  
45.         }  
46.     };  
47. class P {  
48.     public: P(int a, int b) {  
49.         cout << "P(int,int),a=" << a << ",b=" << b << endl;  
50.     }  
51.     P(initializer_list < int > initlist) {  
52.         cout << "P(initializer_list<int>),values= ";  
53.         for_each(initlist.begin(), initlist.end(), bind1st(Print(), "%d "));  
54.         cout << endl;  
55.     }  
56. };  
57. int main() {  
58.     P p {  
59.         77, 5  
60.     };  
61.     P q(77, 5);  
62. }  

    创建p时会适配到初始化列表为参数；而创建q时则会适配到以两个int为参数。注意即使没有initializer_list版本的构造器，编译一样可以通过，因为发生了initializer_list的自动类型转换。

    3.initializer_list源码分析

    template<class _E>

    class initializer_list

    {

    const _E* __array;

    size_t __len;

    // The compiler can call a private constructor.

    initializer_list(const _E* __a, size_t __l)

    : __array(__a), __len(__l) { }

    public:

    initializer_list()

    : __array(NULL), __len(0) { }

    // Number of elements.

    size_t size() const

    { return __len; }

    // First element.

    const _E* begin() const

    { return __array; }

    // One past the last element.

    const _E* end() const

    { return begin() + size(); }

    };

    }

    Initializer内部使用array数据结构的迭代器（指针），但他并不内含一个array，可以视作是一个浅拷贝。在C++11的标准库中，所有的容器都添加了使用initializer_list的版本。

    诸如max()之类的函数也添加了接受Initializer_list的版本。以前，max只能进行两个值的比较；而现在，可以采用类似于max({1,2,3,4,5})之类的表达方式进行任意参数的比较。

    4. 由于初始化列表带来的explicit关键字用法的变化

    在C++11之前，explicit关键字只能用于构造函数具有一个实参，有这样的情况：

63. class  Complex  {        
64.     int  real,  imag;        
65.     explicit  Complex(int  re,  int  im  =  0):  real(re),  imag(im)  {}        
66.     Complex  operator  +  (const  Complex  &  x)  {            
67.         return  Complex((real  +  x.real),   (imag  +  x.imag));        
68.     }    
69. };    
70. int  main()  {        
71.     Complex  a(0,  1);        
72.     Complex  b  =  a  +  1;  //error,explicit    
73. }    

    四、 新的for语法

74. for (decl: coll) {  
75.     Statement;  
76. }  

    类似于python的for语法，decl指向coll容器的每一个元素，直到容器尾。如果你想对容器中的元素进行修改，可以采用传引用的方法，如下例：

77. for (auto & elem: vec) {  
78.     elem += 3;  
79. }  

    也可以是向量组中的每一个元素都能作为单参构造的参数，其实就是通过构造函数实现的自动类型转换。

    五、保留默认函数的方法

    一般情况下，当我们创建了构造函数，拷贝构造函数，赋值操作的情况时候，默认的函数就会自动消失。现在，C++11允许我们使用=default和=delete两个关键字声明来保留或删除原有的，如下例：

80. Zoo(const Zoo & ) = delete; //删除已经存在的版本，可能是编译器给的或自己写的；  
81. Zoo(const Zoo & ) = default; //采用默认定义，对于构造函数，就是保留无参构造。  

    右值引用（C++11引入）也可以使用这两个关键字，右值引用的知识在之后介绍。

    在使用这两个关键字时，其能否通过编译，关键就是看是否有二义性，或是否有先定义了再=delete的情形（在这种情形下，你先已经定义了一个函数，然后又说要删除这个函数，编译器会不知所措）

    利用=delete，可以实现不允许拷贝构造的类。在Singleton设计模式，原来是采用了一个私有的拷贝构造函数，现在我们有了新的方法。

    六、别名（Alias）（using新用法）

    1. 模板别名

    在C++11之后，using有了新的用法：

82. template  <  typename  T  >  
83. using  Vec  =  std::vector  <  T,  MyAlloc  <  T  >>  ;    

    用宏是达不到这样的效果的 。

    在之前提及过的模板模板参数中，也涉及到了using的用法。使用模板模板参数的方法编译器无法调用向量参数的默认值，而每一个容器都有一个默认的第二参数，即内存分配器；具体写法在笔者《C++高级编程》笔记中有涉及到，不再重复讲述。

    2. 类型别名（与typedef相似）

    以下两条语句等价：

84. typedef void( * p)(int, int);  
85. using func = void( * )(int, int);  

    第二种方式（新的）提高了可读性。

    七、无异常声明noexcept

86. void foo() noexcept;  

    表示foo不再抛出异常。我们知道，C++的异常处理是逐级上报的形式，那么这种情况下也就是说，如果foo()内部发生了异常，异常只在foo内部处理，如果foo处理不了，就直接中断程序（否则则会一直抛到main才退出程序）。这提高了异常处理的效率。

    需要注意的是，右值引用的移动语义构造和赋值必须有noexpect声明。

    八、关于继承的两个关键字

    1.override

87. Struct Base {  
88.     virtual void vfunc(float) {}  
89. };  
90. Struct Derived1: base {  
91.     virtual void vfunc(int) {}  
92. };  

    有时候难免会发生写错的情况，如上例，我们本想复写这一虚函数，不过不小心写错了。

    在C++11中添加了一个安全检查关键字 override：

93. Struct Derived1: base {  
94.     virtual void vfunc(int) override {}  
95. };  

    这样如果你写下来override，则相当于告诉编译器自己要复写，编译器发现没有match会报错。

    2.final

    用于虚函数中，高速编译器，这个类或是这个虚函数不再允许派生或复写。例如：

    struct Base final{…};