类型

< cpp‎ | language

对象引用函数(包括函数模板特化)和表达式具有称为类型的性质,它限制了对这些实体所容许的操作,并给原本寻常的位序列提供了语义含义。

类型的分类

C++ 类型系统由以下类型组成:

  • bool 类型;
  • 字符类型:
  • 窄字符类型:
  • 通常字符类型(charsigned charunsigned char
  • char8_t 类型(C++20 起)
  • 宽字符类型(char16_tchar32_t (C++11 起)wchar_t);
  • 有符号整数类型(short intintlong intlong long int (C++11 起));
  • 无符号整数类型(unsigned short intunsigned intunsigned long intunsigned long long int (C++11 起));
  • 到对象的左值引用类型;
  • 到函数的左值引用类型;
  • 到对象的右值引用类型;
  • 到函数的右值引用类型;
(C++11 起)

对于除引用和函数以外的每个类型,类型系统还支持该类型的三个附加 cv 限定版本constvolatileconst volatile)。

根据类型的各项性质,将它们分组到不同的类别之中:

类型的命名

通过以下方式来声明一个指代类型的名字

在 C++ 程序中对没有名字的类型进行常常需要被涉指;为此而设的语法被称为 类型标识。命名类型 T 的类型标识的语法与省略了标识符的对 T 类型的变量或函数的声明语法完全一致,但声明语法中的 声明说明符序列 被限制为 类型说明符序列 ,另外仅当类型标识出现于非模板类型别名声明的右侧时才可以定义新类型。

int* p;               // 声明一个指向 int 的指针
static_cast<int*>(p); // 类型标识为 "int*"
 
int a[3];   // 声明一个含有 3 个 int 的数组
new int[3]; // 类型标识为 "int[3]" (称作 new-类型标识)
 
int (*(*x[2])())[3];      // 声明一个含有 2 个函数指针的数组
                          // 这些函数指针指向的函数返回指向(含有 3 个 int 的数组)的指针
new (int (*(*[2])())[3]); // 类型标识为 "int (*(*[2])())[3]"
 
void f(int);                    // 声明一个接收 int 并返回 void 的函数
std::function<void(int)> x = f; // 类型模板形参为类型标识 "void(int)"
std::function<auto(int) -> void> y = f; // 同上
 
std::vector<int> v;       // 声明一个含有 int 的 vector
sizeof(std::vector<int>); // 类型标识为 "std::vector<int>"
 
struct { int x; } b;         // 创建一个新类型并声明该类型的一个对象 b
sizeof(struct{ int x; });    // 错误:不能在 sizeof 表达式中定义新类型
using t = struct { int x; }; // 创建一个新类型并声明 t 为该类型的一个别名
 
sizeof(static int); // 错误:存储类说明符并不是类型说明符序列的一部分
std::function<inline void(int)> f; // 错误:函数说明符也不是

声明文法的 声明符 部分在移除了名字后被称为 抽象声明符

类型标识可用于下列情形:

类型标识经过一些修改可用于下列情形:

  • 函数形参列表中(省略形参名时),类型标识中的类型说明符序列声明说明符序列代替(特别是允许使用某些存储类说明符);
  • 用户定义转换函数名中,抽象声明符不能包含函数或数组运算符。

详述类型说明符

详述类型说明符能用于指代先前声明过的类名(类、结构体或联合体)或先前声明过的枚举名,即使该名字被非类型声明隐藏。它们亦可用于声明新的类名。

详见详述类型说明符

静态类型

对程序进行编译时分析所得到的表达式的类型被称为表达式的静态类型。程序执行时静态类型不会更改。

动态类型

若某个泛左值表达式指代某个多态对象,则其最终派生对象的类型被称为其动态类型。

// 给定
struct B { virtual ~B() {} }; // 多态类型
struct D: B {}; // 多态类型
D d; // 最终派生对象
B* ptr = &d;
// (*ptr) 的静态类型为 B
// (*ptr) 的动态类型为 D

对于纯右值表达式,动态类型始终与静态类型相同。

不完整类型

下列类型是不完整类型

  • void 类型(可有 cv 限定);
  • 不完整定义的对象类型

下列语境都要求类型 T 完整:

(通常在必须知道 T 的大小和布局时要求它完整。)

如果翻译单元中出现了这些情况中的任何情况,该类型的定义就必须在相同翻译单元中出现。否则不必出现。

不完整定义的对象类型可以变完整:

  • 类类型(例如 class X)可在翻译单元中的一处不完整而在其之后补充完整;类型 class X 在这两处相同:
class X;              // X 是不完整类型
extern X* xp;         // xp 是指向不完整类型的指针
 
void foo() {
  xp++;               // 非良构: X 不完整
}
 
struct X { int i; };  // 现在 X 是完整类型
 
X x;
void bar() {
  xp = &x;            // OK:类型是“指向 X 的指针”
  xp++;               // OK:X 完整
}
  • 数组对象的声明类型可以是不完整类类型的数组,从而它不完整;若类类型在翻译单元中的后面完整,则该数组类型变得完整;两处的数组类型相同。
  • 数组对象的声明类型可为未知边界数组,从而在翻译单元的一处不完整,并在之后变完整;两处的数组类型(“含有 T 的未知边界数组”与“含有 NT 的元素数组”)不同。

未知边界数组的指针的类型,或由 typedef 声明定义为未知边界数组的类型,无法变得完整。

extern int arr[];   // arr 的类型不完整
typedef int UNKA[]; // UNKA 是不完整类型
UNKA* arrp;         // arrp 是指向不完整类型的指针
UNKA** arrpp;
 
void foo() {
  arrp++;           // 错误:不完整类型
  arrpp++;          // OK:UNKA* 的大小已知
}
 
int arr[10];        // 现在 arr 的类型完整了
 
void bar() {
  rrp = &arr;       // 错误:类型不同
  arrp++;           // 错误:UNKA 无法变得完整
}

参阅