捡个将军做男友啥网站能看/百度应用

前言

C++的类型描述方式是从C语言继承来的，并且进行了扩充（例如引用、非静态成员函数、模板实参等）。但由于C语言中的类型描述方式就略微有点「反人类」，再经C++扩展后就有点「反碳基生物」了~

是的，当我第一次看到这种描述符的时候，我也觉得能写出这玩意的肯定不是碳基生物……没准是用偏硅酸盐合成的新型物种……

void (Test::*(Test::*const &)() const)() const

更离谱的是，上面这种类型如果通过type_traits以后会变成什么？

using type = void (Test::*(Test::*const &)() const)() const;
std::remove_const_t<type>; // 这又是个啥类型呢？

好吧，但愿这个引子可以让读者产生兴趣，而不是劝退（才怪……）。

但，真的理解了以后，emmm…确实也是人类能理解的吧（或许当我理解它的那一刻，我的体内就已经在合成$Si{O}_3^{2-}$了吧……【手动捂脸】）

因此，本篇就来盘一盘C++的类型描述符，带读者由浅入深，一步一步征服它。

先从指针类型说起

指针类型其实是指针的默认解类型

首先我们应当知道，「指针类型」本身，指的就是「用于保存内存地址的变量类型」。而对于内存地址来说，都是一样的（不存在XXX类型的内存地址这种说法）。所以，照理说，「指针类型」应该就都是一种类型，表示这种类型的数据，应当解释为内存地址。我们这里暂且把这种指针类型起名为ptr_t：

void Demo() {using ptr_t = void *; // 可以先忽略这一行int a;double b;ptr_t p1 = nullptr; // 空地址ptr_t p2 = &a; // 用于保存a的地址ptr_t p3 = &b; // 用于保存b的地址ptr_t p4 = &p2; // 用于保存p2的地址
}

只是，通常情况下，我们仅仅拿到一个内存地址是没什么意义的（难道只是为了把它打印出来吗？），拿这个内存肯定是为了操作这个内存上的数据，而我们只知道这个数据的地址是不够的，我们还得知道，要用什么样的方式来解释存在这里的数据，也就是「指针的解类型」。例如，我们「用int的方式来解p2指针」，也就是从p2的值所表示的地址处开始，向高地址方向取sizeof(int)个字节的数据，按照小端序组装起来，并把首位认为是符号位，然后读出（或者写入）这个整数。比如说把读出来的这个值赋给另一个变量y，代码写作：

int y = *(int *)p2; // 表示把p2这个指针，按照int方式解出来，得到的值赋值给y

但如果每次都去指定指针的解类型，会很麻烦，所以我们就希望能给这个指针添加一个「默认解类型」，也就是说，在定义这个指针类型的时候，给它指定一个默认的解类型，如果后续不指定类型，直接解指针的话，就用这种默认的解类型。

从C++的语法上来说，类型+星号，表示定义一个指定了默认解类型的指针类型。比如说：

int *p5 = &a; // p5是指针类型，默认解类型是intint z = *p5; // 没有指定解类型的时候，选用默认的解类型，也就是int类型

同理，如果「默认解类型」是「一个指针类型」的话，也是一样的：

ptr_t *p6 = &p5; // p6的默认解类型是指针类型ptr_t p7 = *p6; // 解出来就是ptr_t类型，所以p7也是指针类型
// 但是因为ptr_t是未指定解类型的指针类型，所以解的时候必须要指定解类型
int w = *(int *)p7;

那么，如果我还希望解出来的指针类型也含有默认解类型的话，就可以用「默认解类型」是「一个指定了『默认解类型』的指针」的指针类型：

int **p8 = &p5; // p8的默认解类型是int *类型
// 所以对p8直接解指针后，得到的就应该是int *类型
int *p9 = *p8;
// 而p9是默认解类型为int的指针类型，解指针后得到int类型
int t = *p9;

上面的例子想表明的是：

1. 只要是指针类型，都是用来保存内存地址的，也就是说它的值仅仅表示地址。
2. 指针类型中，星号前面的部分表示的「指针的默认解类型」。
3. 多级指针本质是「默认解类型为『指针类型』的指针类型」，所以无论前面的类型多么复杂，它都属于这个指针的默认解类型，而不影响这个指针本身。

泛型指针类型其实是无默认解类型的指针类型

再回头来看看刚才这个ptr_t，刚才有一句我让大家先忽略的那一行定义：

using ptr_t = void *;

我们希望表示的是「不含默认解类型」的指针类型，按照语法，默认解类型是T的指针类型就是T *，那么「不含」默认解类型的，就可以理解为默认解类型是「空」的，自然就是void *。

所以我们常说的「泛型」指针，之所以能「泛」，其实就是因为，没有指定默认解类型而已，并没有什么稀奇的。

指针类型转换本质是指针默认解类型转换

既然我们知道了指针类型其实表示的是它的默认解类型，那么指针类型的转换自然是表示它默认解类型的转换了：

void *p = &a;
int *p2 = (int *)p; // void *转换为int *，其实就是默认解类型从空变为int

所以前面例子中我们「指定解类型」的解指针方式，本质就是把指针转换为「默认解类型是对应类型」的指针类型，再去解指针：

int y = *(int *)p; // 其实是把p转换为int *类型，再解指针，自然得到int类型

那么，把「含有默认解类型的指针类型」转换为「不含默认解类型的指针类型」应当是一种较为安全的静态转换，因此，我们使用static_cast来代替之前C风格的转换：

int *p = &a;
void *p2 = static_cast<void *>(p); // int * → void *

另外，上面这种转换也支持隐式转换：

int *p = &a;
void *p2 = p; // int * → void *

同理，给「不含默认解类型的指针类型」赋予一个默认解类型，变为「含有默认解类型的指针类型」也是一种较为安全的静态转换，所以同样使用static_cast：

void *p = &a;
int *p2 = static_cast<int *>(p); // void * → int *

不过这种转换不支持隐式转换，必须强转。

而「默认解类型为A的指针类型」转换为「默认解类型是B的指针类型」（这里的A，B都不是void）则被认为是一种相对不安全的转换，因为改变指针的默认解类型相当于「重新解释了」指针所指数据的含义。因此，这里要使用reinterpret_cast：

int *p = &a;
char *p2 = reinterpret_cast<char *>(p); // int * → char *

const修饰的指针

const关键字在C/C++中并不是代表真正的常量，而是应当理解为read-only，也就是只读。用const修饰的类型不可被修改，只能读取。

而对于指针来说，指针本身既然是一种数据类型，那么也就存在「只读的指针类型」。另一方面，指针的默认解类型也可能是一种只读类型，所以，我们主要是要区分这个const修饰的是指针类型本身，还是指针的默认解类型中的类型。

int *p1; // 指针本身可变，默认解类型是int
const int *p2; // 指针本身可变，默认解类型是const int
int *const p3; // 指针本身不可变，默认解类型是int
const int *const p4; // 指针本身不可变，默认解类型是const int

当我们理解了何为指针的解类型后，其实就很好判断了。如果const出现在解类型中，那么它与指针本身是否可变无关，只有在修饰指针本身的时候，才表示这个指针变量是个只读变量。

而在指针类型的表达式中，我们首先应当找到那个「特殊的星号」，由这个星号隔开，其余的内容都是解类型。

比如在int *const p3中，星号只有一个，自然就是那个特殊的（或者说最内层的），星号前面（外面）的都是解类型，而这个const出现在特殊型号的右边（内部），因此，它修饰的是这个变量本身，那么我们就说p3是只读类型。而剩下的部分，是它的解类型，也就是int。

同理，在const int *p2中，也只出现了一个星号，它就是特殊的那个。星号后面没有const修饰，所以p2是可变的，而它的解类型是const int，也就是说这里的const修饰的是解类型。

C++中提供了一个模板工具std::remove_const，用于去掉类型的const修饰，这里要注意的是，它去掉的是类型本身的const，而跟解类型是完全没有关系的，会原样保留，比如说：

std::remove_const_t<const int *>; // const int *
std::remove_const_t<int *const>; // int *
std::remove_const_t<const int *const>; // const int *

那么，对于多级指针呢？同理，我们需要找到特殊的星号（最内层的星号），由他隔离开，外边都是解类型。

int *const *p1; // p1可变，解类型是int *const 
int **const *p2; // p2可变，解类型是int **const
const int **p3; // p3可变， 解类型是const int *
int *const *const p4; // p4不可变，解类型是int *const 

所以，它们如果去掉const也是同理，只会去掉那个修饰变量本身的const，而解类型不会改变：

std::remove_const_t<int *const *>; // int * const *
std::remove_const_t<int **const *>; // int **const *
std::remove_const_t<const int **>; // const int **
std::remove_const_t<int *const *const>; // int *const *

总结就是一句，找到最内层的星号（目前的例子其实都是最右边的星号），由它分隔，外面（目前例子都是左边）都表示解类型，与变量本身无关，里面（目前例子都是右边）才是修饰变量本身的，如果出现了const，就表示变量本身不可变。

后面的章节将会介绍真正的「里面」和「外面」并不符合前面的「右边」和「左边」规律的例子。

数组类型

单纯的数组类型

笔者采访过一些C++程序员（以C++为主要开发语言的从业者），惊奇地发现有一多半的人都不了解「数组类型」。尽管他们可能天天见、天天使用，但从来没有意识到这种类型的存在形态。

举个例子来说：

int arr[] {1, 2, 3};

请问arr是什么类型？数组类型？指针类型？int *类型？

揭晓答案，arr是int [3]类型，解释为，含有3个int元素的数组类型。我相信大家对「数组类型」肯定不陌生，也能解释清楚它的元素类型、个数等。但是乍一看到这个int [3]类型，还是有很多人会懵圈的。

的确，我们并不容易注意到arr的类型就是int [3]，这主要是因为，C++的数组类型通常情况下只会在定义的时候用到，之后就全部改用指针和偏移量去操作了。

那么现在就请读者知晓，数组类型本身包含了「元素类型」和「元素个数」这两个因素的。它是独立存在一种类型，并不是指针/结构体/整数等的语法糖。只不过，数组类型可以隐式转换为首元素的指针类型：

auto p = arr; // p是int *类型
// 也就是等价于
int *p = (int *)arr;

所以我们一定要清楚，数组是数组，指针是指针，这是两种不同的类型，只是可以隐式转换而已。要想验证也很简单，用std::is_same来验证，或者直接通过sizeof也可以间接验证：

int arr[] {1, 2, 3};
auto p = arr;std::is_same_v<decltype(arr), decltype(p)>; // false
std::is_same_v<int [3], int *>; // false// 假设64位环境
sizeof(arr); // 12
sizeof(p); // 8
sizeof(int [3]); // 12
sizeof(int *); // 8

识别清数组类型，会对我们在模板实例化时避坑有很大帮助。比如说下面的写法就是有问题的：

std::shared_ptr<int *> p = new int[5];

因为p被识别为int *类型的智能指针，那么在p析构时，只会调用delete方法，而不是delete []，使得这片堆空间没有被正确释放。

正确的写法是：

std::shared_ptr<int[]> p = new int[5]; // 要用数组类型，而不是指针类型

再比如，模板的自动类型推导中，如果传入数组也会被识别为数组类型：

template <typename T>
struct Test {Test(const T &t) {}
};void Demo() {int arr[] {1, 2, 3};auto p = arr;Test t1{arr}; // t1是Test<int[3]>类型Test t2{p}; // t2是Test<int *>类型
}

const数组类型

那么，是否存在不可变数组类型呢？我们知道，数组一旦确定，它的元素类型不可变，元素个数也不可变，所以但从数组的两个因素来讲，所有的数组都是不可变的，因此也就不存在所谓可变还是不可变数组类型。

那么对于数组来说，唯一可以控制是否可变的就是元素类型，因此，只存在const T [N]类型，而不存在类似于T (const) [N]之类的。注意，T const [N]和const T [N]等价，const都是修饰元素类型的。

既然const是修饰元素类型的，那么它隐式转换为指针后，这个const也一定修饰的是解类型，而不是指针本身：

const int arr[] {1, 2, 3};
auto p = arr; // p的类型是const int *

数组指针类型

数组指针类型其实就是指「默认解类型是数组类型的指针类型」。一定要注意，这跟「数组首元素指针类型」是不同的！数组类型不能转化成它，而是要通过取地址运算得到：

int arr[] {1, 2, 3};
auto p = &arr; // p的类型是int (*)[3]

这里我们不得不引出C/C++中类型描述符的一大绕不开的「缺陷」了，那就是类型描述符并不一定是从左向右，而是可能从里向外。前面章节我们提到过「内部」和「外部」的说法，也是为了跟这种类型描述符的特点相对应。

从「数组类型」开始，就已经符合这种由内向外的描述方式了：

int arr[3];

arr是int [3]类型，但并没有写作int[3] arr而是写作了int arr[3]。我们注意到，变量名被夹在了类型描述符的中间。对于更复杂的这种类型描述方式来说，我们需要由内向外来解释，首先要找到变量名，然后逐层向外来阅读。例如：

int (*p)[3];

首先找到变量名p，由括号限定的最内层有一个型号，表示p本身是一个指针。那么再向外一层则表示指针的解类型，这里它的解类型是int [3]。所以综合来说，p是一个解类型为int [3]类型的指针，也就是我们通常所说的「数组指针」类型。

与之对应的一个容易搞混的是：

int *q[3];

同样先找到变量名q，向外一层则是数组，右边表示数组元素个数，左边表示数组元素类型。所以q是数组，元素类型是int *，也就是我们通常说的「指针数组」。

【第二篇待更】