类型别名，auto，decltype

1 int main()
2 {
3     typedef char *ps; // ps是类型char*的别名
4     const ps p1 = 0; // p1是指向char的常量指针
5     const ps *p2; // p2是一个指针，它的对象是指向char的常量指针
6     return 0;
7 }

 1 int main()
 2 {
 3     /*
 4     当引用被用作初始值时，真正参与初始化的其实是引用的对象的值，
 5     此时编译器以引用对象的类型作为auto的类型。
 6     */
 7     auto i = 0, &r = i;
 8     auto a = r; // a是一个整数
 9     /*
10     auto一般会忽略掉顶层const，底层const会保留下来
11     */
12     const int ci = i, &cr = ci;
13     auto b = ci; // b是一个整数（ci的顶层const特效被忽略掉了）
14     auto c = cr; // c是一个整数（cr是ci的别名，ci本身是一个顶层const）
15     auto d = &i; // d是一个整型指针
16     auto e = &ci; // e是一个指向常量的指针（对常量对象取地址是一种底层const）
17     /*
18     如果希望推断出的auto类型是一个顶层const，需要明确指出
19     */
20     const auto f = ci; // ci的推演类型是int，f是const int
21     /*
22     可以将引用的类型设为auto，此时原来的初始化规则仍然使用；设置一个类型
23     为auto的引用时，初始值中的顶层const仍然保留。如果我们给初始值绑定一个引用，
24     则此时的常量就不是顶层const了。
25     */
26     auto &g = ci; // g是一个整型常量引用，绑定到ci
27     //auto &h = 42; // 错误：不能为非常量引用绑定字面值
28     const auto &j = 42; // 可以为常量引用绑定字面值
29     return 0;
30 }

1 int main()
2 {
3     const int ci = 0, &cj = ci;
4     decltype(ci) x = 0; // x的类型是const int
5     decltype(cj) y = x; // y的类型是const int &，y绑定到变量x
6     //decltype(cj) z; // 错误：z是个引用，必须初始化
7     return 0;
8 }

1 int main()
2 {
3     int i = 42, *p = &i, &r = i;
4     decltype(r + 0) b; // 加法的结果是int，因此b是一个未初始化的int
5     //decltype(*p) c; // 错误：c是int&，必须初始化
6     return 0;
7 }

1 int main()
2 {
3     int i = 42;
4     //decltype((i)) d; // 错误：d是int&，必须初始化
5     decltype(i) e; // e是一个未初始化的int
6     return 0;
7 }