10 C++11

使用GNU C++编译器（g++）编译包含C++11语法特性的代码，需要加上“-std=c++11”编译选项。例如：

1
g++ -std=c++11 hello.cpp

10.1 简化代码

10.1.1 类型推导

10.1.1.1 auto

10.1.1.1.1 auto的基本用法

​x
1
// auto1.cpp
2

3
// auto的基本用法
4

5
#include <iostream>
6
#include <typeinfo>
7

8
using namespace std;
9

10
int main(void) {
11
    auto a = 1; // a:int，常限定被丢弃
12
    cout << typeid(a).name() << endl; // i
13

14
    auto b = new auto(2); // b:int*
15
    cout << typeid(b).name() << endl; // Pi
16

17
    auto const* c = &a, d = 3; // c:int const*, d:int const
18
    cout << typeid(c).name() << endl; // PKi
19
    cout << typeid(d).name() << endl; // i
20
    // cout << ++d << endl; // 编译错误，d带有常限定
21

22
    // auto const* e = &a, f; // 编译错误，虽然根据e的初值&a已经可以推导出auto，但
23
                              // f仍然需要被显式初始化，且不能与之前的推断发生矛盾
24
    // auto const* g = &a, h = 3.0; // 编译错误，类型推导不能有二义性
25

26
    // 在旧语法中，auto变量即自动变量存储于栈区，而static变量即静态变量存储于
27
    // 静态区，二者不可同时使用，但C++11的auto关键字已不再作为存储类型指示符
28

29
    static auto i = 4.;
30
    cout << typeid(i).name() << endl; // d
31

32
    // auto int j; // 编译错误，C++11的auto关键字已不再作为存储类型指示符
33

34
    // auto k; // 编译错误，auto并不能代表一个实际的类型声明，它只是一个类
35
               // 型声明的占位符。使用auto声明的变量必须马上初始化，以让编
36
               // 译器推断出它的实际类型，并在编译时将auto替换为真正的类型
37

38
    return 0;
39
}

10.1.1.1.2 auto同指针或引用结合使用

xxxxxxxxxx
45
1
// auto2.cpp
2

3
// auto同指针或引用结合使用
4

5
#include <iostream>
6
#include <typeinfo>
7

8
using namespace std;
9

10
int main(void) {
11
    int a = 0;
12

13
    auto* b = &a; // auto=int, b:int*
14
    cout << typeid(b).name() << endl; // Pi
15

16
    // 即使不把auto声明为指针，其亦可被推导为指针类型
17

18
    auto c = &a; // auto=int*, c:int*
19
    cout << typeid(c).name() << endl; // Pi
20

21
    // 当表达式带有引用属性时，auto会抛弃其引用属性，直接推导为原始类型
22

23
    auto& d = a; // auto=int, d:int&
24
    cout << &d << ' ' << &a << endl; // 0x7ffc19fd2540 0x7ffc19fd2540
25
    auto e = d; // auto=int, e:int
26
    cout << &e << ' ' << &d << endl; // 0x7ffc19fd2544 0x7ffc19fd2540
27

28
    // 当表达式带有CV（只读/挥发）限定时，auto会抛弃其CV限定
29

30
    auto const f = a; // auto=int, f:int const
31
    // cout << ++f << endl; // 编译错误，f带有常限定
32
    auto g = f; // auto=int, g:int
33
    cout << ++g << endl; // 1
34

35
    // 但如果auto和引用或指针结合使用，表达式的CV限定会被保留下来
36

37
    auto const& h = a; // auto=int, h:int const&
38
    // cout << ++h << endl; // 编译错误，h带有常限定
39
    auto& i = h; // auto=int const, i:int const&
40
    // cout << ++i << endl; // 编译错误，i带有常限定
41
    auto* j = &h; // auto=int const, j:int const*
42
    // cout << ++*j << endl; // 编译错误，j带有常限定
43

44
    return 0;
45
}

10.1.1.1.3 auto使用的限制

xxxxxxxxxx
63
1
// auto3.cpp
2

3
// auto使用的限制
4

5
#include <iostream>
6
#include <typeinfo>
7

8
using namespace std;
9

10
// auto不能用于函数的参数
11

12
// void foo(auto a = 0) {
13
//     cout << typeid(a).name() << endl;
14
// }
15

16
class A {
17
public:
18
    int x = 0;
19

20
    // auto不能用于类的非静态成员变量
21

22
    // auto y = 1;
23

24
    static auto const z = 2;
25
};
26

27
template<typename T>
28
class B {
29
public:
30
    B(T const& arg) : var(arg) {}
31

32
    T var;
33
};
34

35
int main (void) {
36
    // auto不能用于函数的参数
37

38
    // foo(1);
39

40
    // auto不能用于类的非静态成员变量
41

42
    A a;
43
    cout << a.x << ' ' /*<< a.y << ' ' */<< a.z << endl; // 0 2
44

45
    // auto不能用于模板的类型实参
46

47
    B<int> b(0);
48
    // B<auto> c = b;
49

50
    // auto不能用于数组元素
51

52
    int d[10];
53
    // auto e[10] = d;
54

55
    // 但可用于指向数组元素的指针和引用整个数组的引用
56

57
    auto f = d; // auto=int*, arr3:int*, arr1代表数组首元素的地址
58
    cout << typeid(f).name() << endl; // Pi
59
    auto& g = d; // auto=int[10], arr4:int (&)[10], arr1代表数组整体
60
    cout << typeid(g).name() << endl; // A10_i
61

62
    return 0;
63
}

10.1.1.1.4 何时使用auto？

xxxxxxxxxx
98
1
// auto4.cpp
2

3
// 何时使用auto？
4

5
#include <iostream>
6
#include <map>
7

8
using namespace std;
9

10
// 借助auto，可以减少模板的类型参数
11

12
class A {
13
public:
14
    A(int arg = 0) : var(arg) {}
15

16
    int get(void) const {
17
        return var;
18
    }
19

20
    void set(int arg) {
21
        var = arg;
22
    }
23

24
private:
25
    int var;
26
};
27

28
class B {
29
public:
30
    B(char const* arg = "") : var(arg) {}
31

32
    char const* get(void) const {
33
        return var;
34
    }
35

36
    void set(char const* arg) {
37
        var = arg;
38
    }
39

40
private:
41
    char const* var;
42
};
43

44
template<typename V, typename X>
45
void foo(X const& x) {
46
    V var = x.get();
47
    cout << var << endl;
48

49
    // 使用var...
50
}
51

52
template<typename X>
53
void bar(X const& x) {
54
    auto var = x.get();
55
    cout << var << endl;
56

57
    // 使用var...
58
}
59

60
int main(void) {
61
    // 借助auto，可以减少模板的类型参数
62

63
    A a(1234);
64
    B b("abcd");
65

66
    foo<int>(a); // 1234
67
    foo<char const*>(b); // abcd
68

69
    bar(a); // 1234
70
    bar(b); // abcd
71

72
    // 借助auto，可以简化复杂类型的书写
73

74
    multimap<string, int> sn;
75

76
    sn.insert(make_pair("张飞", 100000));
77
    sn.insert(make_pair("赵云", 150000));
78
    sn.insert(make_pair("张飞", 200000));
79
    sn.insert(make_pair("关羽", 250000));
80
    sn.insert(make_pair("赵云", 300000));
81
    sn.insert(make_pair("关羽", 350000));
82

83
    pair<multimap<string, int>::iterator,
84
        multimap<string, int>::iterator> range1 = sn.equal_range("张飞");
85
    int sum1 = 0;
86
    for (multimap<string, int>::iterator it = range1.first;
87
        it != range1.second; ++it)
88
        sum1 += it->second;
89
    cout << sum1 << endl; // 300000
90

91
    auto range2 = sn.equal_range("张飞");
92
    int sum2 = 0;
93
    for (auto it = range2.first; it != range2.second; ++it)
94
        sum2 += it->second;
95
    cout << sum2 << endl; // 300000
96

97
    return 0;
98
}

10.1.1.2 decltype

10.1.1.2.1 计算表达式的类型

xxxxxxxxxx
43
1
// decltype1.cpp
2

3
// 计算表达式的类型
4

5
#include <iostream>
6
#include <typeinfo>
7

8
using namespace std;
9

10
int main(void) {
11
    int a = 0;
12

13
    // decltype的值就是表达式的类型本身
14

15
    decltype(a) b = 1; // b:int
16
    cout << typeid(b).name() << endl; // i
17

18
    // decltype在编译时而非运行时计算表达式的类型
19

20
    decltype(++a) c = a; // c:int&
21
    cout << a << endl; // 0
22

23
    // decltype会保留表达式的引用属性和CV限定
24

25
    int const& d = 3;
26
    decltype(d) e = d; // e:int const&
27
    cout << &e << ' ' << &d << endl; // 0x7ffcf815f3dc 0x7ffcf815f3dc
28
    // cout << ++e << endl; // 编译错误，e带有常限定
29

30
    // decltype可以和指针联用
31

32
    decltype(a) *f = &a, **g = &f; // f:int*, g:int**
33
    cout << typeid(f).name() << endl; // Pi
34
    cout << typeid(g).name() << endl; // PPi
35

36
    // decltype可以和引用及CV限定符联用
37

38
    decltype(a) const& h = a; // h:int const&
39
    cout << &h << ' ' << &a << endl; // 0x7ffcf815f3d8 0x7ffcf815f3d8
40
    // cout << ++h << endl; // 编译错误，h带有常限定
41

42
    return 0;
43
}

10.1.1.2.2 类型计算规则

xxxxxxxxxx
99
1
// decltype2.cpp
2

3
// 类型计算规则
4

5
#include <iostream>
6

7
using namespace std;
8

9
class Obj {
10
public:
11
    Obj(int arg) : var(arg) {}
12

13
    int var;
14

15
    static int const sta = 0;
16
};
17

18
ostream& operator<< (ostream& os, Obj const& obj) {
19
    return os << '(' << obj.var << ',' << obj.sta << ')';
20
}
21

22
// 规则1：对标识符及成员标识符表达式，直接取表达式的类型
23

24
void rule1(void) {
25
    int a = 0;
26
    int const volatile& b = a;
27

28
    decltype(a) c = a; // c:int
29
    decltype(b) d = b; // d:int const volatile&
30

31
    Obj e = 1;
32
    decltype(e.var) f = 2; // f:int
33
    decltype(Obj::sta) g = 3; // g:int const
34

35
    cout << a << ' ' << b << ' ' << c << ' ' << d << ' ' <<
36
            e << ' ' << f << ' ' << g << endl;
37
}
38

39
// 规则2：对函数调用表达式，取函数返回值的类型
40

41
void rule2(void) {
42
    int&  lvr(void); // 返回左值引用
43
    int&& rvr(void); // 返回右值引用
44
    int   prv(void); // 返回纯右值
45
    Obj   obj(void); // 返回类对象
46

47
    int const&  clvr(void); // 返回常左值引用
48
    int const&& crvr(void); // 返回常右值引用
49
    int const   cprv(void); // 返回常纯右值
50
    Obj const   cobj(void); // 返回常类对象
51

52
    int i = 0;
53
    decltype(lvr()) a = i; // a:int&
54
    decltype(rvr()) b = 1; // b:int&&
55
    decltype(prv()) c = 2; // c:int
56
    decltype(obj()) d = 3; // d:Obj
57

58
    int j = 4;
59
    decltype(clvr())e = j; // e:int const&
60
    decltype(crvr())f = 5; // f:int const&&
61
    decltype(cprv())g = 6; // g:int, 基本类型返回值忽略CV限定
62
    decltype(cobj())h = 7; // h:Obj const, 类类型返回值CV限定有效
63

64
    cout << a << ' ' << b << ' ' << c << ' ' << d << ' ' <<
65
            e << ' ' << f << ' ' << g << ' ' << h << endl;
66
}
67

68
// 规则3：对其它表达式，若表达式的类型为左值则取该类型的左值引用，否则取表达式的类型
69

70
void rule3(void) {
71
    int a = 0;
72

73
    decltype(a) b = 1; // b:int, 根据规则1
74
    decltype((a)) c = a; // c : int&, a是左值，因此括号表达式(a)
75
                         // 也是左值，由规则3，c的类型为左值引用
76

77
    Obj const d = 2;
78
    decltype(d.var) e = 3; // e:int, 根据规则1
79
    decltype((d.var)) f = d.var; // f:int const&, 常对象的成员变量都是常
80
                                 // 左值，由规则3，f的类型为常左值引用
81

82
    int g = 4, h = 5;
83
    decltype(++g)   i = g; // i:int&
84
    decltype(g++)   j = 6; // j:int
85
    decltype(g = h) k = g; // k:int&
86
    decltype(g + h) l = 7; // l:int
87

88
    cout << a << ' ' << b << ' ' << c << ' ' << d << ' ' <<
89
            e << ' ' << f << ' ' << g << ' ' << h << ' ' <<
90
            i << ' ' << j << ' ' << k << ' ' << l << endl;
91
}
92

93
int main(void) {
94
    rule1();
95
    rule2();
96
    rule3();
97

98
    return 0;
99
}

10.1.1.2.3 何时使用decltype？

xxxxxxxxxx
84
1
// decltype3.cpp
2

3
// 何时使用decltype？
4

5
#include <iostream>
6
#include <vector>
7
#include <map>
8

9
using namespace std;
10

11
// 打印可写容器中的元素
12

13
template<typename C>
14
void printWritable(C& c) {
15
    cout << "可写容器：";
16

17
    for (typename C::iterator it = c.begin(); it != c.end(); ++it)
18
        cout << *it << ' ';
19

20
    cout << endl;
21
}
22

23
// 打印只读容器中的元素
24

25
template<typename C>
26
void printReadonly(C const& c) {
27
    cout << "只读容器：";
28

29
    for (typename C::const_iterator it = c.begin(); it != c.end(); ++it)
30
        cout << *it << ' ';
31

32
    cout << endl;
33
}
34

35
// 打印任意容器中的元素
36

37
template<typename C>
38
void print(C& c) {
39
    cout << "任意容器：";
40

41
    for (decltype(c.begin()) it = c.begin(); it != c.end(); ++it)
42
        cout << *it << ' ';
43

44
    cout << endl;
45
}
46

47
int main(void) {
48
    vector<int> wv; // 可写容器
49
    wv.push_back(10);
50
    wv.push_back(20);
51
    wv.push_back(30);
52
    wv.push_back(40);
53
    wv.push_back(50);
54
    vector<int> const rv = wv; // 只读容器
55

56
    printWritable(wv);
57
    printReadonly(rv);
58

59
    print(wv);
60
    print(rv);
61

62
    map<string, vector<int> > scores;
63
    scores["张飞"].push_back(70);
64
    scores["张飞"].push_back(85);
65
    scores["赵云"].push_back(75);
66
    scores["赵云"].push_back(90);
67
    scores["关羽"].push_back(80);
68
    scores["关羽"].push_back(95);
69

70
    // ...
71

72
    int sum1 = 0; // 在冗长的代码中确定某个变量的类型将十分困难
73
    for (size_t i = 0; i < scores["张飞"].size(); ++i)
74
        sum1 += scores["张飞"][i];
75
    cout << sum1 << endl; // 155
76

77
    decltype(scores)::mapped_type::value_type sum2 = // 通过decltype可以很方便地
78
        decltype(scores)::mapped_type::value_type(); // 根据变量表达式计算其类型
79
    for (size_t i = 0; i < scores["张飞"].size(); ++i)
80
        sum2 += scores["张飞"][i];
81
    cout << sum2 << endl; // 155
82

83
    return 0;
84
}

10.1.1.2.4 返回类型后置

xxxxxxxxxx
42
1
// decltype4.cpp
2

3
// 返回类型后置
4

5
#include <iostream>
6
#include <typeinfo>
7

8
using namespace std;
9

10
template<typename X, typename Y>
11
auto add(X const& x, Y const& y) -> decltype(x + y) {
12
    return x + y;
13
}
14

15
double foo(int arg) {
16
    return arg / 2.0;
17
}
18

19
int foo(double arg) {
20
    return int(arg * 2);
21
}
22

23
template<typename T>
24
auto bar(T const& arg) -> decltype(foo(arg)) {
25
    return foo(arg);
26
}
27

28
int main(void) {
29
    auto a = add(1, 0.5);
30
    cout << typeid(a).name() << ' ' << a << endl; // d 1.5
31

32
    auto b = add (1, 'A');
33
    cout << typeid(b).name() << ' ' << b << endl; // i 66
34

35
    auto c = bar(1);
36
    cout << typeid(c).name() << ' ' << c << endl; // d 0.5
37

38
    auto d = bar(0.5);
39
    cout << typeid(d).name() << ' ' << d << endl; // i 1
40

41
    return 0;
42
}

10.1.2 模板改进

10.1.2.1 为模板定义别名

10.1.2.1.1 不能用typedef为模板定义别名

xxxxxxxxxx
38
1
// alias1.cpp
2

3
// 不能用typedef为模板定义别名
4

5
#include <iostream>
6
#include <typeinfo>
7

8
using namespace std;
9

10
template<typename A, typename B>
11
class X {};
12

13
// 可以用typedef为具体类型定义别名
14

15
typedef unsigned int uint_t;
16

17
// 当然也包括由模板实例化产生的类
18

19
typedef X<string, int> xsi_t;
20

21
// 但不能用typedef为模板或部分模板定义别名
22

23
// typedef X x_t;
24
// typedef X<string, B> xs_t;
25

26
int main(void) {
27
    uint_t a; // a:unsigned int
28
    xsi_t b; // b:X<string, int>
29
    // x_t<string, int> c;
30
    // xs_t<int> d;
31

32
    cout << typeid(a).name() << endl;
33
    cout << typeid(b).name() << endl;
34
    // cout << typeid(c).name() << endl;
35
    // cout << typeid(d).name() << endl;
36

37
    return 0;
38
}

10.1.2.1.2 可以用using为包括模板在内的任何类型定义别名

xxxxxxxxxx
38
1
// alias2.cpp
2

3
// 可以用using为包括模板在内的任何类型定义别名
4

5
#include <iostream>
6
#include <typeinfo>
7

8
using namespace std;
9

10
template<typename A, typename B>
11
class X {};
12

13
// 可以用using为具体类型定义别名
14

15
using uint_t = unsigned int;
16

17
// 当然也包括由模板实例化产生的类
18

19
using xsi_t = X<string, int>;
20

21
// 甚至可以用using为模板或部分模板定义别名
22

23
template<typename A, typename B> using x_t = X<A, B>;
24
template<typename B> using xs_t = X<string, B>;
25

26
int main(void) {
27
    uint_t a; // a:unsigned int
28
    xsi_t b; // b:X<string, int>
29
    x_t<string, int> c; // c:X<string, int>
30
    xs_t<int> d; // d:X<string, int>
31

32
    cout << typeid(a).name() << endl;
33
    cout << typeid(b).name() << endl;
34
    cout << typeid(c).name() << endl;
35
    cout << typeid(d).name() << endl;
36

37
    return 0;
38
}

10.1.2.2 函数模板的缺省模板参数

10.1.2.2.1 C++98/03中的函数模板不能带有缺省模板参数

在C++98/03中，只有类模板可以带有缺省模板参数，函数模板不能带有缺省模板参数。

xxxxxxxxxx
46
1
// defparam1.cpp
2

3
// C++98/03中的函数模板不能带有缺省模板参数
4

5
#include <iostream>
6
#include <typeinfo>
7

8
using namespace std;
9

10
// 在C++98/03中，只有类模板可以带有缺省模板参数
11

12
template<typename A = int, typename B = double, typename C = string>
13
class X {
14
public:
15
    static void foo(void) {
16
        cout << typeid(A).name() << ' ' << typeid(B).name() << ' ' << typeid(C).name() << endl;
17
    }
18
};
19

20
// 在C++98/03中，函数模板不能带有缺省模板参数
21

22
// template<typename A = int, typename B = double, typename C = string>
23
// void foo(void) {
24
//     cout << typeid(A).name() << ' ' << typeid(B).name() << ' ' << typeid(C).name() << endl;
25
// }
26

27
int main(void) {
28
    // 在C++98/03中，只有类模板可以带有缺省模板参数
29

30
    X<char, short, long>::foo();
31
    X<char, short>::foo();
32
    X<char>::foo();
33
    X<>::foo(); // "<>"不可省略
34

35
    // 在C++98/03中，函数模板不能带有缺省模板参数
36

37
    // foo<char, short, long>();
38
    // foo<char, short>();
39
    // foo<char>();
40
    // foo<>();
41
    // foo();
42

43
    return 0;
44
}
45

46
// g++ -std=c++98 defparam1.cpp

10.1.2.2.2 C++11中的类模板和函数模板都可以带有缺省模板参数

xxxxxxxxxx
82
1
// defparam2.cpp
2

3
// C++11中的类模板和函数模板都可以带有缺省模板参数
4

5
#include <iostream>
6
#include <typeinfo>
7

8
using namespace std;
9

10
// 在C++11中，类模板可以带有缺省模板参数
11

12
template<typename A = int, typename B = double, typename C = string>
13
class X {
14
public:
15
    static void foo(void) {
16
        cout << typeid(A).name() << ' ' << typeid(B).name() << ' ' << typeid(C).name() << endl;
17
    }
18
};
19

20
// 在C++11中，函数模板也可以带有缺省模板参数
21

22
template<typename A = int, typename B = double, typename C = string>
23
void foo(void) {
24
    cout << typeid(A).name() << ' ' << typeid(B).name() << ' ' << typeid(C).name() << endl;
25
}
26

27
// 只要满足隐式推断的条件，函数模板参数的缺省值不是非写在参数表最后
28

29
template<typename A = int, typename B, typename C = string>
30
A bar(B b) {
31
    cout << typeid(A).name() << ' ' << typeid(B).name() << ' ' << typeid(C).name() << endl;
32

33
    A a = A();
34
    C c = C();
35

36
    return a;
37
}
38

39
// 无法隐式推断的模板参数取缺省值，否则取隐式推断的
40
// 类型。只要隐式推断生效，模板参数的缺省值即被忽略
41

42
template<typename A = int, typename B = double, typename C = string>
43
A hum(B b) {
44
    cout << typeid(A).name() << ' ' << typeid(B).name() << ' ' << typeid(C).name() << endl;
45

46
    A a = A();
47
    C c = C();
48

49
    return a;
50
}
51

52
int main(void) {
53
    // 在C++11中，类模板可以带有缺省模板参数
54

55
    X<char, short, long>::foo();
56
    X<char, short>::foo();
57
    X<char>::foo();
58
    X<>::foo(); // "<>"不可省略
59

60
    // 在C++11中，函数模板也可以带有缺省模板参数
61

62
    foo<char, short, long>();
63
    foo<char, short>();
64
    foo<char>();
65
    foo<>();
66
    foo(); // "<>"可以省略
67

68
    // 只要满足隐式推断的条件，函数模板参数的缺省值不是非写在参数表最后
69

70
    bar<char, short, long>(100);
71
    bar<char, short>(100);
72
    bar<char>(100); // 隐式推断B=int
73
    bar<>(100); // 隐式推断B=int
74
    bar(100); // 隐式推断B=int
75

76
    // 无法隐式推断的模板参数取缺省值，否则取隐式推断的
77
    // 类型。只要隐式推断生效，模板参数的缺省值即被忽略
78

79
    hum(100); // 隐式推断B=int，忽略其缺省值double
80

81
    return 0;
82
}

10.1.2.3 模板实参表的右尖括号

10.1.2.3.1 C++98/03标准模板实参表的右尖括号

在C++98/03标准中，连续的两个右尖括号会被编译器解释为右移位操作符，而非模板实参表结束，因此它们之间至少应保留一个空格。

xxxxxxxxxx
37
1
// delimiter1.cpp
2

3
// C++98/03标准模板实参表的右尖括号
4

5
#include <iostream>
6
#include <typeinfo>
7

8
using namespace std;
9

10
template<typename T>
11
void ptype(void) {
12
    cout << typeid(T).name() << endl;
13
}
14

15
template<typename T>
16
class Dummy {};
17

18
template<int x>
19
int square(void) {
20
    return x * x;
21
}
22

23
int main(void) {
24
    // 在C++98/03标准中，连续的两个右尖括号会被编译器解释为右移位
25
    // 操作符，而非模板实参表结束，因此它们之间至少应保留一个空格
26

27
    // ptype<Dummy<int>>(); // 编译错误
28
    ptype<Dummy<int> >();
29

30
    // 这里的">>"会被正确解释为右移位操作符
31

32
    cout << square<6>>1>() << endl; // 9
33

34
    return 0;
35
}
36

37
// g++ -std=c++98 delimiter1.cpp

10.1.2.3.2 C++11标准模板实参表的右尖括号

在C++11标准中，要求编译器对模板的右尖括号做单独处理，使之能正确区分右移位操作符和模板实参表结束，因此无需再留空格。

xxxxxxxxxx
35
1
// delimiter2.cpp
2

3
// C++11标准模板实参表的右尖括号
4

5
#include <iostream>
6
#include <typeinfo>
7

8
using namespace std;
9

10
template<typename T>
11
void ptype(void) {
12
    cout << typeid(T).name() << endl;
13
}
14

15
template<typename T>
16
class Dummy {};
17

18
template<int x>
19
int square(void) {
20
    return x * x;
21
}
22

23
int main(void) {
24
    // 在C++11标准中，要求编译器对模板的右尖括号做单独处理，使之
25
    // 能正确区分右移位操作符和模板实参表结束，因此无需再留空格
26

27
    ptype<Dummy<int>>();
28

29
    // 如果不加小括号，这里的">>"会被错误解释为模板参数表结束和大于号，导致编译错误
30

31
    // cout << square<6>>1>() << endl; // 编译错误
32
    cout << square<(6>>1)> () << endl; // 9
33

34
    return 0;
35
}

10.1.3 列表初始化

10.1.3.1 C++98/03标准没有通用的初始化语法

在C++98/03中，对象初始化方法有很多种，每一种都有各自的适用范围和作用。没有任何一种初始化方法可以通用于所有情况。

xxxxxxxxxx
64
1
// initlist1.cpp
2

3
// C++98/03标准没有通用的初始化语法
4

5
#include <iostream>
6
#include <algorithm>
7
#include <iterator>
8

9
using namespace std;
10

11
struct Student {
12
    char name[256];
13

14
    struct Date {int y, m, d;} bday;
15
};
16

17
class Complex {
18
public:
19
    Complex(double r = 0, double i = 0) : r(r), i(i) {}
20

21
    // 有公有拷贝构造函数，不一定会被调用
22

23
    Complex(Complex const& complex) : r(complex.r), i(complex.i) {
24
        cout << "拷贝构造：" << &complex << "->" << this << endl;
25
    }
26

27
    friend ostream& operator<<(ostream& os, Complex const& complex) {
28
        return os << '(' << complex.r << showpos << complex.i << noshowpos << "i)";
29
    }
30

31
private:
32
    // 无公有拷贝构造函数，编译器一定报错
33

34
    // Complex(Complex const& complex);
35

36
    double r, i;
37
};
38

39
int main(void) {
40
    int a = 123; // 赋值形式的初始化
41
    cout << a << endl;
42

43
    double b(1.23); // 构造形式的初始化
44
    cout << b << endl;
45

46
    int c[] = {100, 200, 300}; // 列表形式的初始化
47
    copy(c, c + sizeof(c) / sizeof(c[0]), ostream_iterator<int>(cout, " "));
48
    cout << endl;
49

50
    Student d = {"张飞", {2011, 11, 11}}; // 列表形式的初始化
51
    cout << d.name << ',' << d.bday.y << '-' << d.bday.m << '-' << d.bday.d << endl;
52

53
    Complex e(1.2, 3.4); // 构造形式的初始化
54
    cout << e << endl;
55

56
    // 对拷贝构造函数的调用，可能会被优化掉，但对拷贝构造函数的语法检查，编译器依然会做
57

58
    Complex f = Complex(1.2, 3.4); // 赋值形式的初始化
59
    cout << f << endl;
60

61
    return 0;
62
}
63

64
// g++ -std=c++98 initlist1.cpp

10.1.3.2 C++11标准提供了通用的列表形式的初始化语法

在C++11中，列表形式的初始化语法被大大扩充了，可用于任何类型对象及其数组的初始化，无论该对象或数组是被静态还是动态创建的。

xxxxxxxxxx
77
1
// initlist2.cpp
2

3
// C++11标准提供了通用的列表形式的初始化语法
4

5
#include <iostream>
6
#include <algorithm>
7
#include <iterator>
8

9
using namespace std;
10

11
struct Student {
12
    char name[256];
13

14
    struct Date {int y, m, d;} bday;
15
};
16

17
class Complex {
18
public:
19
    Complex(double r = 0, double i = 0) : r(r), i(i) {}
20

21
    Complex const operator+(Complex const& complex) const {
22
        // 列表形式的初始化语法甚至可以用在函数的返回值上
23

24
        return {r + complex.r, i + complex.i};
25
    }
26

27
    friend ostream& operator<< (ostream& os, Complex const& complex) {
28
        return os << '(' << complex.r << showpos << complex.i << noshowpos << "i)";
29
    }
30

31
private:
32
    // 无公有拷贝构造函数，编译器并不报错
33

34
    Complex(Complex const& complex);
35

36
    double r, i;
37
};
38

39
int main(void) {
40
    int a  = {123};
41
    cout << a << endl;
42

43
    double b{1.23}; // 左花括号前面的等号写不写都一样
44
    cout << b << endl;
45

46
    int c[]{100, 200, 300};
47
    copy(c, c + sizeof(c) / sizeof(c[0]), ostream_iterator<decltype(*c)>(cout, " "));
48
    cout << endl;
49

50
    Student d{"张飞", {2011, 11, 11}};
51
    cout << d.name << ',' << d.bday.y << '-' << d.bday.m << '-' << d.bday.d << endl;
52

53
    Complex e{1.2, 3.4};
54
    cout << e << endl;
55

56
    Complex f = {1.2, 3.4}; // 左花括号前面有没有等号，都不需要拷贝构造
57
    cout << f << endl;
58

59
    cout << e + f << endl;
60

61
    Complex* g {new Complex{1.2, 3.4}};
62
    cout << *g << endl;
63
    delete g;
64

65
    g = new Complex[3]{{1.1, 2.2}, {3.3, 4.4}, {5.5, 6.6}};
66
    copy(g, g + 3, ostream_iterator<decltype(*g)>(cout, " "));
67
    cout << endl;
68
    delete[] g;
69

70
    cout << Complex{1.2, 3.4} << endl; // 匿名对象
71

72
    Complex const (&h)[3]{{1.1, 2.2}, {3.3, 4.4}, {5.5, 6.6}}; // 匿名数组
73
    copy(h, h + 3, ostream_iterator<decltype(*h)>(cout, " "));
74
    cout << endl;
75

76
    return 0;
77
}