类型

对象、引用、函数（包括函数模板特化）和表达式都拥有一个称为类型的属性，它既约束了对这些实体允许的操作，又为原本通用的位序列提供了语义含义。

不具名的类型常常需要在 C++ 程序中被引用；用于此目的的语法被称为类型标识。命名类型 T 的类型标识的语法，与类型为 T 的变量或函数的声明的语法完全相同，只是标识符被省略，例外是声明文法的声明符序列被约束为类型说明符序列，并且仅当类型标识出现在非模板类型别名声明的右手侧时，才可以定义新类型。

int* p;               // declaration of a pointer to int
static_cast<int*>(p); // type-id is "int*"
 
int a[3];   // declaration of an array of 3 int
new int[3]; // type-id is "int[3]" (called new-type-id)
 
int (*(*x[2])())[3];      // declaration of an array of 2 pointers to functions
                          // returning pointer to array of 3 int
new (int (*(*[2])())[3]); // type-id is "int (*(*[2])())[3]"
 
void f(int);                    // declaration of a function taking int and returning void
std::function<void(int)> x = f; // type template parameter is a type-id "void(int)"
std::function<auto(int) -> void> y = f; // same
 
std::vector<int> v;       // declaration of a vector of int
sizeof(std::vector<int>); // type-id is "std::vector<int>"
 
struct { int x; } b;         // creates a new type and declares an object b of that type
sizeof(struct { int x; });   // error: cannot define new types in a sizeof expression
using t = struct { int x; }; // creates a new type and declares t as an alias of that type
 
sizeof(static int); // error: storage class specifiers not part of type-specifier-seq
std::function<inline void(int)> f; // error: neither are function specifiers

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

类型标识可以在下列情形中使用

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

在动态异常规范中。

（直至 C++17）

类型标识可以在下列情形中经修改后使用

在函数的形参列表中（当省略形参名时），类型标识使用声明符序列而非类型说明符序列（特别地，允许一些存储类说明符）；
在用户定义的转换函数的名字中，抽象声明符不能包含函数或数组运算符。

[编辑] 详述类型说明符

详述类型说明符可以用于指代先前声明的类名（类、结构体或联合体）或先前声明的枚举名，即使该名字被非类型声明隐藏。它们也可以用于声明新的类名。

参见详述类型说明符以了解详情。

[编辑] 静态类型

由程序的编译时分析产生的表达式的类型，被称为表达式的静态类型。静态类型在程序执行期间不会改变。

[编辑] 动态类型

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

// given
struct B { virtual ~B() {} }; // polymorphic type
struct D : B {};               // polymorphic type
 
D d; // most-derived object
B* ptr = &d;
 
// the static type of (*ptr) is B
// the dynamic type of (*ptr) is D

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

[编辑] 不完整类型

下列类型是不完整类型

类型 void（可能 cv 限定）；
不完整定义的对象类型:
- 已声明（例如通过前向声明）但未定义的类类型；
- 未知边界数组;
- 不完整类型元素数组；
- 枚举类型，从声明点到其底层类型被确定为止。

所有其他类型都是完整类型。

下列任何上下文都需要类型 T 是完整类型

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

（通常，当 T 的大小和布局必须已知时。）

如果这些情形中的任何一种出现在翻译单元中，则类型的定义必须出现在同一翻译单元中。否则，则不是必需的。

一个不完整定义的对象类型可以被完成

类类型（例如 class X）可能在一个翻译单元中的某点被视为不完整，而在稍后被视为完整；类型 class X 在这两点是相同的类型

struct X;            // declaration of X, no definition provided yet
extern X* xp;        // xp is a pointer to an incomplete type:
                     // the definition of X is not reachable
 
void foo()
{
    xp++;            // ill-formed: X is incomplete
}
 
struct X { int i; }; // definition of X
X x;                 // OK: the definition of X is reachable
 
void bar()
{
    xp = &x;         // OK: type is “pointer to X”
    xp++;            // OK: X is complete
}

数组对象的声明类型可能是个不完整类类型的数组，因此是不完整的；如果类类型稍后在翻译单元中被完成，则数组类型变为完整；这两点的数组类型是相同的类型。
数组对象的声明类型可能是未知边界数组，因此在一个翻译单元中的某点是不完整的，而在稍后是完整的；这两点的数组类型（“T 的未知边界数组”和“N 个 T 的数组”）是不同的类型。

指向或引用未知边界数组的指针或引用的类型永久指向或引用不完整类型。由 typedef 声明命名的未知边界数组永久指代不完整类型。在任一情况下，数组类型都不能被完成

extern int arr[];   // the type of arr is incomplete
typedef int UNKA[]; // UNKA is an incomplete type
 
UNKA* arrp;         // arrp is a pointer to an incomplete type
UNKA** arrpp;
 
void foo()
{
    arrp++;         // error: UNKA is an incomplete type
    arrpp++;        // OK: sizeof UNKA* is known
}
 
int arr[10];        // now the type of arr is complete
 
void bar()
{
    arrp = &arr;    // OK: qualification conversion (since C++20)
    arrp++;         // error: UNKA cannot be completed
}

[编辑] 缺陷报告

下列行为变更缺陷报告被追溯应用到先前发布的 C++ 标准。

DR	应用于	已发布行为	正确行为
CWG 328	C++98	不禁止不完整类型的类成员如果从不创建类类型的对象	非静态类数据成员需要是完整类型
CWG 977	C++98	枚举类型变为完整类型的点在其定义中不清晰	一旦确定底层类型，类型即为完整类型
CWG 1362	C++98	到类型 `T*` 或 `T&` 的用户定义转换	需要 `T` 是完整类型
不需要	C++98	CWG 2006	cv 限定的 void 类型是对象类型和完整类型
从两个类别中排除	C++98	CWG 2448	只有 cv 非限定类型可以是整型和浮点类型
允许 cv 限定类型	C++98	CWG 2630 不清晰类是否在类的定义出现的翻译单元外部被视为完整	类是完整类型如果其定义在此情况下是可达的
CWG 2643	C++98	指向未知边界数组的指针的类型不能被完成（但它已经是完整类型）	被指向的数组类型不能被完成
LWG 2139	C++98	“用户定义类型”的含义不清晰	定义并使用“程序定义的类型”替代
LWG 3119	C++11	不清晰闭包类型是否是程序定义的类型	已明确

[编辑] 参考文献

C++23 标准 (ISO/IEC 14882:2024)

6.8.2 基本类型 [basic.fundamental]

C++20 标准 (ISO/IEC 14882:2020)

6.8.2 基本类型 [basic.fundamental]

C++17 标准 (ISO/IEC 14882:2017)

6.9.1 基本类型 [basic.fundamental]

C++14 标准 (ISO/IEC 14882:2014)

3.9.1 基本类型 [basic.fundamental]

C++11 标准 (ISO/IEC 14882:2011)

3.9.1 基本类型 [basic.fundamental]

C++98 标准 (ISO/IEC 14882:1998)

3.9.1 基本类型 [basic.fundamental]

[编辑] 参见

类型特征	用于查询类型属性的编译时模板接口
C 文档关于类型

[编辑] 外部链接

1.	Howard Hinnant 的 C++0x 类型树

[1] signed char 和 unsigned char 是窄字符类型，但它们不是字符类型。换句话说，窄字符类型的集合不是字符类型的集合的子集。

[1]

编译器支持
独立和宿主式
语言
标准库
标准库头文件
具名要求
特性测试宏 (C++20)
语言支持库
概念库 (C++20)
诊断库
内存管理库
元编程库 (C++11)
通用工具库
容器库
迭代器库
范围库 (C++20)
算法库
字符串库
文本处理库
数值库
日期和时间库
输入/输出库
文件系统库 (C++17)
并发支持库 (C++11)
执行控制库 (C++26)
技术规范
符号索引
外部库

注释
ASCII
标点符号
名称和标识符
类型
基本类型
对象
作用域
对象生存期
存储期和链接
定义和 ODR
名字查找
限定名字查找
非限定名字查找
as-if 规则
未定义行为
内存模型
多线程执行和数据竞争 (C++11)
字符集和编码
翻译阶段
`main` 函数
模块 (C++20)
契约 (C++26)

cppreference.cn

命名空间

变体

视图

操作

类型

目录

[编辑] 类型分类

[编辑] 其他类别

[编辑] 已弃用的类别

[编辑] 程序定义的类型

[编辑] 类型命名