前言
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…确实也是人类能理解的吧(或许当我理解它的那一刻,我的体内就已经在合成 S i O 3 2 − SiO_3^{2-} SiO32−了吧……【手动捂脸】)
因此,本篇就来盘一盘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是指针类型,默认解类型是int
int 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;
上面的例子想表明的是:
- 只要是指针类型,都是用来保存内存地址的,也就是说它的值仅仅表示地址。
- 指针类型中,星号前面的部分表示的「指针的默认解类型」。
- 多级指针本质是「默认解类型为『指针类型』的指针类型」,所以无论前面的类型多么复杂,它都属于这个指针的默认解类型,而不影响这个指针本身。
泛型指针类型其实是无默认解类型的指针类型
再回头来看看刚才这个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 *
,也就是我们通常说的「指针数组」。