类型

 

C++

语言

标准库头文件

独立与有宿主实现

具名要求

语言支持库

概念库 (C++20)

诊断库

工具库

字符串库

容器库

迭代器库

范围库 (C++20)

算法库

数值库

输入/输出库

本地化库

正则表达式库 (C++11)

原子操作库 (C++11)

线程支持库 (C++11)

文件系统库 (C++17)

技术规范

 

C++ 语言

 

基本概念

语言关键词

翻译阶段

注释

main() 函数

名字和标识符

类型

基础类型

对象

作用域

对象生存期

存储期与链接

定义和单一定义规则（ODR）

名字查找

有限定名称查找

无限定名称查找

如同规则

未定义行为

内存模型

 

对象、引用，包含函数模板特化的函数和表达式拥有称为类型的属性，它限制对这些实体容许的操作，并提供语义含义给原本泛化的位序列。

类型的分类

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

• 基础类型（参阅 std::is_fundamental ）：

• void 类型（参阅 std::is_void ）；
• std::nullptr_t 类型(C++11 起) （参阅 std::is_null_pointer ）；
• 算术类型（参阅 std::is_arithmetic ）：

• 浮点类型（ float 、 double 、 long double）（参阅 std::is_floating_point ）；
• 整数类型（参阅 std::is_integral ）：

• bool 类型；
• 字符类型：

• 窄字符类型：

• 通常字符类型（ char 、 signed char 、 unsigned char ）
• char8_t 类型

• 宽字符类型（ char16_t 、 char32_t 、 wchar_t ）；

• 有符号整数类型（ short int 、 int 、 long int 、 long long int ）；
• 无符号整数类型（ unsigned short int 、 unsigned int 、 unsigned long int 、 unsigned long long int ）；

• 合成类型（参阅 std::is_compound ）：

• 引用类型（参阅 std::is_reference ）：

• 左值引用类型（参阅 std::is_lvalue_reference ）；

• 到对象的左值引用类型；
• 到函数的左值引用类型；

• 右值引用类型（参阅 std::is_rvalue_reference ）；

• 到对象的右值引用类型；
• 到函数的右值引用类型；

• 指针类型（参阅 std::is_pointer ）：

• 指向对象指针类型；
• 指向函数指针类型；

• 指向成员指针类型（参阅 std::is_member_pointer ）：

• 指向数据成员指针类型（参阅 std::is_member_object_pointer ）；
• 指向成员函数指针类型（参阅 std::is_member_function_pointer ）；

• 数组类型（参阅 std::is_array ）；
• 函数类型（参阅 std::is_function ）；
• 枚举类型（参阅 std::is_enum ）；
• 类类型：

• 非联合类型（参阅 std::is_class ）；
• 联合类型（参阅 std::is_union ）。

对于每个引用和函数以外的类型，类型系统支持该类型的三个附加 cv 限定版本（ const 、 volatile 及 const volatile ）。

类型被分组到基于其属性的各种类别中：

• 对象类型是非函数类型、非引用类型且非 void 类型的（可有 cv 限定的）类型（参阅 std::is_object ）；
• 标量类型是（可有 cv 限定的）算术、指针、指向成员指针、枚举和 std::nullptr_t 类型（参阅 std::is_scalar ）；
• 平凡类型（参阅 std::is_trivial ）、 POD 类型（参阅 std::is_pod ）、字面类型（参阅 std::is_literal_type ）和其他类别列于类型特性库或作为具名类型要求。

类型的命名

能通过以下方式，声明一个指代类型的名称：

• 类声明；
• 枚举声明；
• typedef 声明；
• 类型别名声明。

常常需要在 C++ 程序中使用无名称的类型；为之而设的语法被称为类型标识。指名类型 T 的类型标识的语法，准确地是在 T 类型变量或函数的声明语法中省略标识符，除了声明文法的 decl-specifier-seq 被制约到 type-specifier-seq ，而仅若类型表示出现在非模板类型别名声明的右侧，才可以定义新类型。

int* p;               // 声明指向 int 的指针
static_cast<int*>(p); // 类型标识为 "int*"
 
int a[3];   // 声明 3 个 int 的数组
new int[3]; // 类型标识为 "int[3]" （称为新类型标识）
 
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); // 错误：存储类指定符不是 type-specifier-seq 的部分
std::function<inline void(int)> f; // 错误：函数指定符也不是

声明文法的 declarator 部分在移除名称后被称为 abstract-declarator 。

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

• 指定转型表达式中的目标类型；
• 作为给 sizeof 、 alignof 、 alignas 、 new 和 typeid 的参数；
• 在类型别名声明的右侧；
• 作为函数声明的尾随返回类型；
• 作为模板类型形参的默认实参；
• 作为模板类型形参的模板实参；
• 在动态异常规定中。

类型标识能在下列情形中带修改使用：

• 在函数参数列表中（省略参数名时），以 decl-specifier-seq 代替 type-specifier-seq 使用类型标识（特别是允许某些存储类指定符）；
• 在用户定义转换函数名中，抽象声明器不能包含函数或数组运算符。

详细类型指定符

详细类型指定符能用于指代先前声明的类名（ class 、 struct 或 union ）或先前声明的 enum 名，即使该名称为非类型声明所隐藏。它们亦可用于声明新类名。

细节见详细类型指定符。

静态类型

从程序的编译时分析产生的表达式类型被称为表达式的静态类型。程序执行时静态类型不更改。

动态类型

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

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

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

不完整类型

下列类型是不完整类型：

• void 类型（可有 cv 限定）；
• 已声明（例如由前置声明）但未定义的类类型；
• 未知边界数组；
• 不完整类型元素的数组
• 从声明点到确定其底层类型的枚举类型。

任何下列语境要求类型 T 完整：

• 返回类型为 T 或参数类型为 T 的函数的定义或对它的调用；
• T 类型对象的定义;
• T 类型非静态数据成员的声明；
• T 类型对象或元素类型为 T 的数组的 new 表达式；
• 应用到 T 类型泛左值的左值到右值转换；
• 到 T 类型的隐式或显式转换；
• 到 T* 或 T& 类型的 标准转换、 dynamic_cast 或 static_cast ，除非从空指针常量或从指向 void 指针转换；
• 应用到 T 类型表达式的类成员访问运算符；
• 应用到 T 类型的 typeid 、 sizeof 或 alignof 运算符；
• 应用到指向 T 指针的算术运算符；
• 有基类 T 的类的定义；
• 赋值给 T 类型左值；
• T 、 T& 或 T* 类型异常的 catch 子句。

（通常在必须知道 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 的未知边界数组”与“ N 个 T 的数组”）是不同类型。

指向未知边界数组指针的类型，或由 typedef 声明定义为未知边界数组的类型，不能变得完整。

参阅

类型 的 C 文档