关键字(keyword)属于保留字，是整个语言范围内预先保留的标识符。每个C++关键字都有特殊的含义。经过预处理后，关键字从预处理记号(preprocessing-token)中区别出来，剩下的标识符作为记号(token)，用于声明对象、函数、类型、命名空间等。不能声明与关键字同名的标识符。
各个版本的ISO C++都规定以下划线接大写字母或下划线起始的标识符保留给实现，编译器可以用这些保留标识符作为扩展关键字，这不保证可移植性。
本篇将尝试总结下C++的73个关键字，分别介绍各个关键字的定义，作用、特性和使用的代码示例。
前面几篇也分别介绍了其他语言的关键字，详细请参考专栏
- Verilog的关键字（上）
- Verilog的关键字（下）
- Python的关键字
- Go的关键字
- C语言的关键字
- C++的关键字
- JavaScript的关键字
C++进阶：https://blog.csdn.net/zhouruifu2015/category_5659847
C++98/03 关键字
ISO C++98/03关键字共63个，此处严格按标准原文排版：
asm, auto, bool, break, case, catch, char, class, const, const_cast, continue, default, delete, do, double, dynamic_cast, else, enum, explicit, export, extern, false, float, for, friend, goto, if, inline, int, long, mutable, namespace, new, operator, private, protected, public, register, reinterpret_cast, return, short, signed, sizeof, static, static_cast, struct, switch, template, this, throw, true, try, typedef, typeid, typename, union, unsigned, using, virtual, void, volatile, wchar_t, while
alignas
alignas用于声明时指定对齐类似于现有的类型。和sizeof类似，两者的操作数都不被求值。
alignof
alignof用于获取取指定表达式指定的（类似sizeof，可以直接是类型名）的对齐(alignment)。
constexpr
类似const但更强大，修饰函数或对象，表示函数结果或对象是编译时决定的常量，以便优化。（const不能修饰一般的函数，也不一定指定声明的对象能编译期的常量表达式，更可能只是只读对象。而在C语言中，const完全只能指定只读对象。）
char16_t
16位字符型，类似char和wchar_t，也是一般只专用于表示字符的整数类型，且设计上用于表示Unicode字符。char16_t是C++11新增的，以克服wchar_t在不同平台上无法保证确定宽度的缺点。
char32_t
32位字符型，类似char和wchar_t，也是一般只专用于表示字符的整数类型，且设计上用于表示Unicode字符。char32_t是C++11新增的，以克服wchar_t在不同平台上无法保证确定宽度的缺点。
decltype
用于编译时推断类型。此外参与函数声明的另一种语法：指定返回auto，同时decltype引导trailing-return-type指定实际应该返回类型。decltype的操作数也不被求值。
nullptr
字面量nullptr是具有std::nullptr_t类型的右值，是空指针常量。C++98/03中表示空指针常量的NULL或0都会在重载中引起混淆，而纯库的解决方案在这里也遇到困难，所以有必要加入新的关键字来专门表示空指针。
noexcept
实践表明动态异常规范会影响运行时性能。新增的noexcept表示静态异常规范，只指定函数（模版）是否有异常抛出，这里noexcept即noexcept(true)，表示没有异常抛出。除了异常规范，noexcept可以作用于一个表达式来判断是否有异常，这对于模版代码非常有用。
static_assert
用于编译时的静态断言：若指定的表达式为false则编译失败。
auto
C++11标准和C++98/03标准的auto是不同的。C++98/03标准中，auto表示自动储存类型；C++11标准中，auto表示由编译器静态判断其应有的类型。
asm
用于语法：
asm-definition:
asm ( string-literal ) ;
意义由实现定义，典型实现中传输其中的字符串给汇编器。
auto
在C++98/03中这个这个关键字用于声明块中的变量的生存期为自动生存期，若是对象同时具有自动存储类，即生存期在块结束时结束。这样的变量被称为局部变量。这个关键字不常用，因为即便省略，声明的默认就是auto的。
在C++11中，auto的含义改变为自动通过初值符推断声明的类型占位符。如声明auto i = 1;，auto就相当于int，因为1是int类型，可以推断出i的类型。也可以使用auto& i等声明，具体推导规则同模版参数类型推导。
*_cast
即const_cast、dynamic_cast、reinterpret_cast、static_cast。
C++风格的类型转换。dynamic_cast是动态的，需要运行时支持；其它都是静态检查，相比C风格的类型转换更加细化，增强了类型安全性。
bool,true,false
bool即布尔类型，属于基本类型中的整数类型，取值为真和假。true和false是具有bool类型的字面量，是右值，分别表示真和假。
break,continue,goto
break用于跳出for或while循环或switch。continue用于跳转到循环起始。goto用于无条件跳转到函数内的标号。结构化程序较少使用goto，更多使用循环代替。
case,default,switch
switch分支语句的起始，根据switch条件跳转到case标号或defalut标记的分支上。
catch,throw,try
用于异常处理。try指定try块的起始，try块后的catch可以捕获异常。异常由throw抛出。throw在函数中还表示动态异常规范，但在C++11中被标记为过时（由noexcept部分取代）。
char,wchar_t
表示字符型和宽字符型这些整数类型（属于基本类型），但一般只专用于表示字符。char（和signed char、unsigned char一起）事实上定义了字节的大小。
const,volatile
const和volatile是类型修饰符，语法类似，在C++中合称为cv-限定符(cv-qualifier)。可以共同使用。用于变量或函数参数声明，也可以限制非静态成员函数。const表示只读类型（指定类型安全性，保护对象不被意外修改），volatile指定被修饰的对象类型的读操作是副作用（因此读取不能被随便优化合并，适合映射I/O寄存器等）。
struct,class,union
用于类型声明。class是一般的类类型。struct在C++中是特殊的类类型，声明中仅默认隐式的成员和基类访问限定与class不同（struct是public，class是private）。union是联合体类型。满足特定条件类类型——POD struct或POD union可以和C语言中的struct和union对应兼容。
class还有个用途是在模版类型声明中作为表示模版类型参数或模版模版参数的语法的必要组成部分。前者也可被typename代替。
delete,new
delete单独使用，表示释放具有动态存储期对象，默认版本调用全局的去配器(deallocator)::operator delete和析构函数。new单独使用，表示请求分配动态存储期对象，默认版本调用全局的分配器(allocator)::operator new和指定的析构函数。和operator连用表示分别表示去配器(operator delete)和分配器(operator new)，用于释放分配器(allocator)的内存和分配内存。operator delete也在分配内存被异常中断时被调用。
do,for,while
循环语句的组成部分。C++支持do-while循环、for循环和while循环。C++11新增了ranged-based for循环，用:分隔声明的对象和指定循环的范围。
数值类型
即double、float、long、int、short、signed、unsigned。
signed和unsigned作为前缀修饰整数类型，分别表示有符号和无符号。signed和unsigned修饰char类型，构成unsigned char和signed char，和char都不是相同的类型；不可修饰wchar_t、char16_t和char32_t。其它整数类型的signed省略或不省略，含义不变。signed或unsigned可单独作为类型，相当于signed int和unsigned int。
double和float专用于浮点数，double表示双精度，精度不小于float表示的浮点数。long double则是C++11指定的精度不小于double的浮点数。
其它关键字表示整数类型。从占用空间大小(sizeof)来看，保证char<=short<=int<=long<=long long。注意这些都不是相同的类型，即便大小和范围都一致；各自具有unsigned版本。其中long long是C++11指定的不小于long的整数。
if,else
条件语句的组成部分。if表示条件，之后else表示否定分支。
enum
构成枚举类型名的关键字。C++11新增带作用域的枚举，用enum class或enum struct（两者等价）声明。
explicit
这个关键字修饰构造函数声明，表示显式构造函数（模版），显式构造函数不参与特定的重载。
C++11从两个角度扩展了用法。其一是适用于转换函数（模版），类似构造函数，避免不需要的重载。其二是列表初始化，除非直接使用std::initializer_list，显式构造函数被列表初始化忽略（在C++98/03中，explicit仅对单一参数调用构造函数有意义，这里打破了这个限制）。
export
导出模版，用于分离编译。当初标准委员会未经充分实践支持匆忙通过了这一决定，被EDG证明具备不现实的可用性（即便EDG唯一地实现了这一个特性，他们也表示反对）。
MSVC、GCC、Clang等其它主流编译器前端都没有实现这一特性，甚至这是唯一明显约定不符合C++98/03的特性。C++11废除了这个export关键字的含义，但保留这个关键字，供以后使用。
extern
extern意为“外来的”，是存储类声明修饰符。这个关键字在C语言中即很不明确，容易被混淆（尤其是extern inline——好在C++没有这种用法）。extern表示被修饰的声明中，名称的链接保持和之前的一致（若已有相同声明存在），或保持默认值（若之前没有相同名称的声明存在）——取决于声明的位置。在命名空间作用域（注意包括全局命名空间），extern表示外部链接；若这里省略extern，则对于const对象，默认具有内部链接；否则表示具有和命名空间一致的链接（若顶层没有嵌套未命名的命名空间，就是外部链接，否则是内部链接）。
C++11新增extern用于模版显式实例化声明，表示不在当前翻译单元实例化模版，而在别处有定义。这可以提升编译效率。
friend
声明友元，使其不受访问权限控制的限制。
inline
声明定义内联函数（模版），提示编译时内联——将所调用的代码嵌入到主调函数中。注意是否内联取决于实现——编译器有权不实际内联，如果它认为这是必要的或更符合预期的目标代码质量。但inline还改变了ODR(One Definition Rule)的适用性。类似函数模版，在头文件直接定义inline函数不会视为重复定义违反ODR而编译出错。C++中，一个函数若声明inline，则每处声明都必须保证是inline，和C语言允许extern inline或static inline不同——尽管C++实现可以提供类似非标准的扩展。注意类成员函数若在类定义内给出定义则隐含inline。
C++11中，新增inline namespace，指示命名空间中的名称同时是外层命名空间直接包含的名称。这便于命名空间的版本管理，减少冲突。
mutable
用于类的非静态非const数据成员，表示不受到成员函数的const的限制，可以在const成员函数中使用。
namespace
表示命名空间——其中可以声明若干标识符，组成的名称与其它命名空间不冲突。
可以声明一个命名空间或命名空间别名。
operator
和操作符连用，指定一个重载了的操作符函数，也包括operator new和operator delete。
private,protected
指定类成员或基类中的名称的访问权限控制，分别表示仅供本类使用、供本类和派生类使用、不设限制。
register
提示声明的对象被放入寄存器中以便得到更好的性能。同inline类似，并非强制；不同的是这个提示经常被现代的编译器无视，因此C++11中被标记为过时的。
return
子程序返回语句，终止当前函数执行，使控制流返回到主调函数的调用后。若返回类型不是void可以同时带返回值。
static
和C语言类似，声明静态存储期对象，或指定一个函数的名称具有内部链接。在C++还有另一个用途——用于类作用域声明，表示声明的成员是类共有的，不需要通过类的对象访问。类的静态数据成员也具有静态存储期，除非被thread_local修饰。
sizeof
返回类型名或表达式具有的类型对应的大小。不能对函数使用（虽然可能有非标准扩展）。C++11新增支持直接对类的数据成员作为操作数（之前无法使用）。sizeof的操作数是不被求值的，利用这一点可以配合模版元编程测试类型正确性。
template
声明一个模板、模版的特化或显式实例化（另见extern）。模版用于打破类型系统的某些限制，推迟类型检查到实例化得到具体的模版实例进行以复用代码，实现泛型和参数化编程。
this
this是一种实体，仅在类的非静态成员中使用，是指向类的对象的指针右值。
typedef
用以给数据类型取别名。字面名义上是定义，实际只是声明——这点和C语言的说法不同。
C++11中可被using新增的用法代替。
virtual
声明虚基类或虚函数。具有虚基类或虚函数的类是多态类(polymorphic class)，需要运行时提供支持来判断成员函数调用分派到的具体类型。
typeid
获取表达式的类型，以std::type_info表示结果，可能抛出std::bad_typeid。当操作数非多态类（引用）类型在编译时即可确定结果，否则需要在运行时取得结果，即RTTI。
typename
告诉编译器一个嵌套的限定名（包含::）中的未知的标识符是一个类型。这只在模板中需要区分依赖名称时使用。
另一种用法是在模版声明参数列表中表示模版类型参数，可被class代替。
using
有两种基本用法：using声明和using指示（using namespace ...）。
前者是声明，引入命名空间或基类作用域内已经被声明的名称。后者引入命名空间内所有的名称。
C++11新增了一类用法，可以代替typename，同时可以配合template使用（typedef基于语法考虑未被允许加入这种用法）。
void
特殊的“空”类型，指定函数无返回值或无参数（在参数列表中只能够唯一地使用），用于表达式转换为void类型以丢弃计算值的必要（C++11加入了discarded-value-expression显式地指出了这一点），或用于void*指针类型。
C++而非C的关键字
关键字的改变
C++11 关键字共73个。
新增关键字：alignas、alignof、char16_t、char32_t、constexpr、decltype、noexcept、nullptr、static_assert、thread_local。
auto 的意义改变。
register 被视为过时的（可能在未来标准移除）。
export 因为实现支持太少（仅Edison Design Group的前端支持），编译效率低下，取消原有意义（仍是关键字，但使用它的程序是错误的），改为保留给未来标准使用。
C++ 的73个关键字
C++是一种广泛使用的编程语言，它具有丰富的关键字，其中包括alignas、alignof、asm和auto等。这些关键字在C++语言中发挥着重要的作用，下面我们来详细介绍一下它们的作用、特性和使用方法。
C++进阶：https://blog.csdn.net/zhouruifu2015/category_5659847
- alignas
alignas是C++11中新增的一个关键字，它用于指定变量或类型的对齐方式。对齐方式是指变量或类型在内存中的存储方式，对齐方式不同可能会影响程序的性能。alignas关键字可以用于变量或类型的定义中。例如：
```
alignas(16) char buffer[1024]; // 定义一个16字节对齐的缓冲区
```
- alignof
alignof是C++11中新增的一个关键字，它用于获取变量或类型的对齐方式。alignof关键字可以用于变量或类型的定义中。例如：
```
alignas(16) char buffer[1024];
cout << "buffer的对齐方式为" << alignof(buffer) << "字节" << endl; // 输出buffer的对齐方式
```
- asm
asm是C++中的一个关键字，它用于嵌入汇编代码。asm关键字可以用于函数内或函数外的任何地方。例如：
```
void delay(int n) {
asm("movl $0, %%eax\n\t"
"1:\n\t"
"addl $1, %%eax\n\t"
"cmp %%eax, %0\n\t"
"jle 1b"
: // 输出参数
: "r"(n) // 输入参数
: "eax" // 受影响的寄存器
);
}
```
- auto
auto是C++11中新增的一个关键字，它用于自动推导变量的类型。auto关键字可以用于变量的定义中。例如：
```
auto a = 10; // 推导出a的类型为int
auto b = 3.14; // 推导出b的类型为double
auto c = "hello"; // 推导出c的类型为const char*
```
- bool
bool是C++中的一个关键字，它用于定义布尔型变量。布尔型变量只有两种值：true和false。bool关键字可以用于变量的定义中。例如：
```
bool flag = true; // 定义一个布尔型变量flag，初始值为true
```
- break
break是C++中的一个关键字，它用于跳出循环语句。当循环条件不满足时，程序会跳出循环并执行循环语句后面的代码。break关键字只能用于循环语句或switch语句中。例如：
```
for (int i = 0; i < 10; i++) {
if (i == 5) {
break; // 当i等于5时跳出循环
}
cout << i << endl;
}
```
- case
case是C++中的一个关键字，它用于在switch语句中匹配一个常量表达式。当switch语句的表达式的值等于case后面的常量表达式时，程序会执行该case语句后面的代码。case关键字只能用于switch语句中。例如：
```
int n = 1;
switch (n) {
case 1:
cout << "n等于1" << endl;
break;
case 2:
cout << "n等于2" << endl;
break;
default:
cout << "n不等于1或2" << endl;
break;
}
```
- catch
catch是C++中的一个关键字，它用于捕获异常。当程序抛出异常时，catch语句会捕获该异常并执行相应的代码。catch关键字只能用于try-catch语句中。例如：
```
try {
int a = 10;
int b = 0;
int c = a / b; // 抛出异常
} catch (exception& e) {
cout << "发生异常：" << e.what() << endl;
}
```
- char
char是C++中的一个关键字，它用于定义字符型变量。字符型变量可以存储单个字符，例如字母、数字或符号。char关键字可以用于变量的定义中。例如：
```
char ch = 'a'; // 定义一个字符型变量ch，初始值为'a'
```
- char16_t
char16_t是C++11中新增的一个关键字，它用于定义16位Unicode字符型变量。Unicode是一种用于表示字符的标准编码，它支持世界上所有的字符。char16_t关键字可以用于变量的定义中。例如：
```
char16_t ch = u'a'; // 定义一个16位Unicode字符型变量ch，初始值为'a'
```
- char32_t
char32_t是C++11中新增的一个关键字，它用于定义32位Unicode字符型变量。char32_t关键字可以用于变量的定义中。例如：
```
char32_t ch = U'a'; // 定义一个32位Unicode字符型变量ch，初始值为'a'
```
- class
class是C++中的一个关键字，它用于定义类。类是C++中的一种数据类型，它可以封装数据和函数，并支持面向对象的编程。class关键字可以用于类的定义中。例如：
```
class Person {
public:
string name;
int age;
void sayHello() {
cout << "Hello, my name is " << name << ", I'm " << age << " years old." << endl;
}
};
```
- const
const是C++中的一个关键字，它用于定义常量。常量是指在程序执行期间不可修改的值，例如数字、字符串或对象。const关键字可以用于变量的定义中，表示该变量为常量。例如：
```
const int n = 10; // 定义一个常量n，初始值为10
```
- const_cast
const_cast是C++中的一个关键字，它用于将const修饰的变量转换为非const类型。const_cast关键字可以用于变量的类型转换中。例如：
```
const int n = 10;
int* p = const_cast<int*>(&n); // 将常量n转换为非常量指针p
```
- constexpr
constexpr是C++11中新增的一个关键字，它用于定义常量表达式。常量表达式是指在编译期间就能够确定值的表达式，例如数字、字符串或对象。constexpr关键字可以用于函数、变量和类的定义中。例如：
```
constexpr int n = 10; // 定义一个常量n，初始值为10
```
- continue
continue是C++中的一个关键字，它用于跳过循环中的某次迭代。当程序执行到continue语句时，它会跳过当前迭代并进入下一次迭代。continue关键字可以用于循环语句中。例如：
```
for (int i = 0; i < 10; i++) {
if (i % 2 == 0) {
continue; // 跳过偶数
}
cout << i << endl;
}
```
- decltype
decltype是C++11中新增的一个关键字，它用于获取表达式的类型。decltype关键字可以用于变量的定义中。例如：
```
int n = 10;
decltype(n) m = n; // 定义一个变量m，类型为int，初始值为n
```
- default
default是C++11中新增的一个关键字，它用于定义类的默认构造函数。默认构造函数是指在不提供任何参数的情况下创建对象的构造函数。default关键字可以用于类的构造函数的定义中。例如：
```
class Person {
public:
Person() = default; // 定义一个默认构造函数
};
```
- delete
delete是C++11中新增的一个关键字，它用于删除函数或类的特定函数。删除函数是指禁止使用某个函数的方法，例如防止对象被复制或移动。delete关键字可以用于函数或类的定义中。例如：
```
class Person {
public:
Person(const Person&) = delete; // 禁止使用复制构造函数
Person& operator=(const Person&) = delete; // 禁止使用赋值运算符
};
```
- do
do是C++中的一个关键字，它用于定义do-while循环。do-while循环是指先执行循环体，再判断循环条件的循环结构。do关键字可以用于循环语句的定义中。例如：
```
int i = 0;
do {
cout << i << endl;
i++;
} while (i < 10);
```
- double
double是C++中的一个关键字，它用于定义双精度浮点数类型。双精度浮点数是指一种能够表示更大范围和更高精度的浮点数类型。double关键字可以用于变量的定义中。例如：
```
double pi = 3.1415926; // 定义一个双精度浮点数pi，初始值为3.1415926
```
- dynamic_cast
dynamic_cast是C++中的一个关键字，它用于将一个指向基类对象的指针或引用转换为指向派生类对象的指针或引用。dynamic_cast关键字可以用于类的定义中。例如：
```
class Base {
public:
virtual void print() {}
};
class Derived : public Base {
public:
void print() {}
};
Base* b = new Derived;
Derived* d = dynamic_cast<Derived*>(b); // 将b转换为Derived类型的指针
```
- else
else是C++中的一个关键字，它用于在if语句中定义一个分支。当if语句的条件不满足时，程序会执行else语句中的代码。else关键字可以用于if语句的定义中。例如：
```
int n = 10;
if (n > 0) {
cout << "n is positive" << endl;
} else {
cout << "n is negative or zero" << endl;
}
```
- enum
enum是C++中的一个关键字，它用于定义枚举类型。枚举类型是指一种能够列出所有可能取值的类型，例如星期几、颜色等。enum关键字可以用于变量的定义中。例如：
```
enum Color {
Red,
Green,
Blue
};
Color c = Red; // 定义一个颜色变量c，初始值为Red
```
- explicit
explicit是C++中的一个关键字，它用于禁止隐式转换。当类中的构造函数被定义为explicit时，编译器将不再自动进行类型转换。explicit关键字可以用于构造函数的定义中。例如：
```
class A {
public:
explicit A(int n) : m_n(n) {}
private:
int m_n;
};
A a1 = 10; // 错误，不能使用隐式转换
A a2(10); // 正确，可以使用显式转换
```
- export
export是C++中的一个关键字，它用于导出模板定义。当一个模板被导出时，它可以在其他文件中使用。export关键字可以用于模板的定义中。例如：
```
export template<typename T>
class Vector {
public:
// ...
};
```
- extern
extern是C++中的一个关键字，它用于声明一个变量或函数是在其他文件中定义的。当一个变量或函数被声明为extern时，它可以在其他文件中使用。extern关键字可以用于变量或函数的定义和声明中。例如：
```
// 在文件a.cpp中定义变量n
int n = 10;
// 在文件b.cpp中声明变量n
extern int n;
// 在文件c.h中声明函数foo
extern void foo();
```
- false
false是C++中的一个关键字，它表示布尔类型的假值。布尔类型是一种只有true和false两个取值的类型。false关键字可以用于变量的定义中。例如：
```
bool b = false; // 定义一个布尔类型变量b，初始值为false
```
- float
float是C++中的一个关键字，它用于定义单精度浮点数类型。单精度浮点数是一种可以表示小数的数据类型，它通常占用4个字节的空间。float关键字可以用于变量的定义中。例如：
```
float f = 3.14f; // 定义一个单精度浮点数变量f，初始值为3.14
```
- for
for是C++中的一个关键字，它用于循环执行代码块。for循环通常用于对一个代码块进行重复执行，可以指定循环的初始条件、循环终止条件和每次循环后执行的操作。for关键字可以用于循环语句的定义中。例如：
```
for (int i = 0; i < 10; i++) {
cout << i << endl;
}
```
- friend
friend是C++中的一个关键字，它用于声明一个函数或类是另一个类的友元。当一个函数或类被声明为友元时，它可以访问声明它为友元的类的私有成员。friend关键字可以用于函数或类的定义中。例如：
```
class A {
public:
friend void foo(); // 声明函数foo是类A的友元
private:
int m_n;
};
void foo() {
A a;
a.m_n = 10; // 可以访问类A的私有成员m_n
}
```
- goto
goto是C++中的一个关键字，它用于跳转到程序中的标签。goto语句通常用于在程序中实现非线性的跳转，但它会使程序的逻辑变得混乱，应该尽量避免使用。goto关键字可以用于标签和跳转语句的定义中。例如：
```
label:
cout << "Hello, world!" << endl;
goto label;
```
- if
if是C++中的一个关键字，它用于控制程序的流程。if语句通常用于根据条件判断是否执行一段代码块，可以指定条件表达式和执行的代码块。if关键字可以用于条件语句的定义中。例如：
```
if (x > 0) {
cout << "x is positive" << endl;
} else {
cout << "x is non-positive" << endl;
}
```
- inline
inline是C++中的一个关键字，它用于声明一个函数是内联函数。内联函数是一种特殊的函数，它的执行过程会被编译器直接插入到调用它的代码中，从而避免了函数调用的开销。inline关键字可以用于函数的定义中。例如：
```
inline int add(int a, int b) {
return a + b;
}
```
- int
int是C++中的一个关键字，它用于定义整数类型。整数是一种可以表示整数的数据类型，它通常占用4个字节的空间。int关键字可以用于变量的定义中。例如：
```
int n = 10; // 定义一个整数变量n，初始值为10
```
- long
long是C++中的一个关键字，它用于定义长整数类型。长整数是一种可以表示比普通整数更大的整数的数据类型，它通常占用8个字节的空间。long关键字可以用于变量的定义中。例如：
```
long n = 1000000000; // 定义一个长整数变量n，初始值为1000000000
```
- mutable
mutable是C++中的一个关键字，它用于声明一个成员变量是可变的。可变成员变量是指在常量成员函数中也可以修改它们的值。mutable关键字可以用于类的成员变量的定义中。例如：
```
class A {
public:
void foo() const {
m_n++; // 可以修改m_n的值
}
private:
mutable int m_n;
};
```
- namespace
namespace是C++中的一个关键字，它用于定义命名空间。命名空间是一种将全局变量、函数和类封装到一个独立的作用域中的机制，可以避免命名冲突。namespace关键字可以用于命名空间的定义中。例如：
```
namespace mynamespace {
int n = 10;
void foo() {
cout << "Hello, world!" << endl;
}
}
```
- new
new是C++中的一个关键字，它用于动态分配内存。动态分配内存是指在程序运行期间根据需要分配内存空间，可以避免浪费内存。new关键字可以用于指针变量的定义中。例如：
```
int *p = new int; // 动态分配一个整数类型的内存空间，并将其地址赋值给指针变量p
```
- noexcept
noexcept是C++中的一个关键字，它用于声明一个函数是不会抛出异常的。不会抛出异常的函数可以提高程序的可靠性和性能。noexcept关键字可以用于函数的定义中。例如：
```
void foo() noexcept {
// 不会抛出异常的代码
}
```
- nullptr
nullptr是C++11中新增的一个关键字，它用于表示空指针。空指针是指不指向任何对象或函数的指针。nullptr关键字可以用于指针变量的初始化和比较。例如：
```
int *p = nullptr; // 指针变量p初始化为空指针
if (p == nullptr) { // 判断指针变量p是否为空指针
// 代码
}
```
- operator
operator是C++中的一个关键字，它用于定义运算符重载函数。运算符重载是指为类定义自定义的运算符行为。operator关键字可以用于运算符重载函数的定义中。例如：
```
class A {
public:
A operator+(const A& other) {
A result;
// 自定义的运算符行为
return result;
}
};
```
- private和protected
private和protected是C++中的两个关键字，它们用于定义类的访问控制。private用于定义只能在类内部访问的成员，而protected用于定义只能在类及其子类中访问的成员。private和protected关键字可以用于类的成员变量和函数的定义中。例如：
```
class A {
public:
void foo() {
// 可以访问m_public和m_protected成员变量
// 但不能访问m_private成员变量
}
private:
int m_private;
protected:
int m_protected;
public:
int m_public;
};
```
- public
public是C++中的一个关键字，它用于定义类的公共成员。公共成员是指可以在类内部和外部访问的成员。public关键字可以用于类的成员变量和函数的定义中。例如：
```
class A {
public:
int m_public;
void foo() {
// 代码
}
};
```
- register
register是C++中的一个关键字，它用于声明寄存器变量。寄存器变量是指存储在CPU寄存器中的变量，可以提高程序的执行效率。register关键字可以用于变量的定义中。例如：
```
register int n = 10; // 声明一个寄存器变量n，并将其初始化为10
```
- reinterpret_cast
reinterpret_cast是C++中的一个关键字，它用于将一个指针或引用转换为另一种指针或引用类型。reinterpret_cast关键字可以用于指针或引用类型的转换。例如：
```
int n = 10;
void *p = &n;
int *q = reinterpret_cast<int*>(p); // 将void指针p转换为int指针q
```
- return
return是C++中的一个关键字，它用于从函数中返回一个值。返回值可以是任何类型，包括基本类型、自定义类型和指针类型等。return关键字可以用于函数的定义中。例如：
```
int foo() {
// 代码
return 0; // 返回一个整数类型的值
}
```
- short
short是C++中的一个关键字，它用于定义短整型变量。短整型变量是指占用内存空间较小的整数类型，通常占用2个字节的内存空间。short关键字可以用于变量的定义中。例如：
```
short n = 10; // 声明一个短整型变量n，并将其初始化为10
```
- signed
signed是C++中的一个关键字，它用于定义有符号整数类型。有符号整数类型是指可以表示正数、负数和0的整数类型。signed关键字可以用于整数类型的定义中。例如：
```
signed int n = -10; // 声明一个有符号整数变量n，并将其初始化为-10
```
- sizeof
sizeof是C++中的一个关键字，它用于获取变量或数据类型的大小。sizeof关键字可以用于变量或数据类型的定义中。例如：
```
int n = 10;
size_t size = sizeof(n); // 获取变量n的大小，并将结果存储在size变量中
```
- static
static是C++中的一个关键字，它用于定义静态变量、静态函数和静态类成员。静态变量、静态函数和静态类成员是指只能在类内部访问的成员，它们的生命周期与程序的生命周期相同。static关键字可以用于变量和函数的定义中，也可以用于类的成员变量和函数的定义中。例如：
```
class A {
public:
static int m_static; // 声明一个静态成员变量m_static
static void foo() {
// 代码
} // 声明一个静态成员函数foo
};
int A::m_static = 0; // 静态成员变量的定义和初始化
```
- static_assert
static_assert是C++11中新增的关键字，它用于在编译时进行断言检查。static_assert关键字可以用于常量表达式的检查，如果表达式的值为false，编译器将会发出错误信息。static_assert关键字可以用于函数和模板的定义中。例如：
```
template<typename T>
void foo(T t) {
static_assert(sizeof(T) == 4, "T must be a 4-byte type");
// 代码
}
```
- static_cast
static_cast是C++中的一个关键字，它用于将一个表达式转换为另一种类型。static_cast关键字可以用于基本类型、指针类型和引用类型的转换。static_cast关键字可以用于变量的定义和赋值中。例如：
```
double d = 3.14;
int n = static_cast<int>(d); // 将double类型的变量d转换为int类型，并将结果赋值给变量n
```
- struct
struct是C++中的一个关键字，它用于定义结构体类型。结构体类型是一种自定义的数据类型，它可以包含多个成员变量和成员函数。struct关键字可以用于结构体类型的定义中。例如：
```
struct Person {
int age;
char name[20];
void sayHello() {
// 代码
}
};
Person p = {20, "Tom"}; // 声明一个结构体变量p，并初始化其成员变量
```
- switch
switch是C++中的一个关键字，它用于编写多分支选择结构。switch关键字可以用于整数类型、字符类型和枚举类型的变量。switch关键字可以用于函数的定义中。例如：
```
int n = 1;
switch(n) {
case 1:
// 代码
break;
case 2:
// 代码
break;
default:
// 代码
break;
}
```
- template
template是C++中的一个关键字，它用于定义模板。模板是一种通用的程序设计工具，可以用于生成特定类型的代码。模板可以用于函数和类的定义中。例如：
```
template<typename T>
void foo(T t) {
// 代码
}
```
- this
this是C++中的一个关键字，它用于指向当前对象。this关键字可以用于成员函数中，用于访问当前对象的成员变量和成员函数。例如：
```
class Person {
public:
void setName(std::string name) {
this->name = name; // 使用this关键字访问当前对象的成员变量
}
private:
std::string name;
};
```
- thread_local
thread_local是C++11中新增的关键字，它用于定义线程局部存储变量。线程局部存储变量是一种线程私有的变量，每个线程都有自己的副本。thread_local关键字可以用于变量的定义中。例如：
```
thread_local int n = 0; // 声明一个线程局部存储变量n
```
- throw
throw是C++中的一个关键字，它用于抛出异常。异常是程序运行时的一种错误情况，可以通过throw关键字来抛出异常。throw关键字可以用于函数的定义中。例如：
```
void foo() {
if (error) {
throw std::runtime_error("Error occurred"); // 抛出异常
}
}
```
- true
true是C++中的一个关键字，它表示布尔类型的真值。布尔类型是一种逻辑类型，只有两个取值：true和false。true关键字可以用于布尔类型的变量的初始化和比较操作中。例如：
```
bool b = true; // 声明一个布尔类型的变量b，并将其初始化为true
if (b == true) { // 比较布尔类型的变量b是否等于true
// 代码
}
```
- try
try是C++中的一个关键字，它用于编写异常处理代码块。异常是程序运行时的一种错误情况，可以通过try关键字来捕获和处理异常。try关键字可以用于函数的定义中。例如：
```
try {
// 可能会抛出异常的代码
} catch (std::exception& e) {
// 处理异常的代码
}
```
- typedef
typedef是C++中的一个关键字，它用于定义类型别名。类型别名是一种将一个类型定义为另一个名字的方式。typedef关键字可以用于类型别名的定义中。例如：
```
typedef int Integer; // 将int类型定义为Integer类型别名
Integer n = 10; // 声明一个Integer类型的变量n，并将其初始化为10
```
- typeid
typeid是C++中的一个关键字，它用于获取一个表达式的类型信息。typeid关键字可以用于变量和表达式的类型信息的获取。例如：
```
int n = 10;
const std::type_info& type = typeid(n); // 获取变量n的类型信息
std::cout << type.name() << std::endl; // 输出变量n的类型名
```
- typename
typename是C++中的一个关键字，它用于指示一个类型是一个类型名称。typename关键字通常用于模板编程中，用于指示一个类型是一个类型名称，而不是一个变量名称。例如：
```
template <typename T>
void foo() {
typename T::iterator iter; // 声明一个T类型的迭代器
// 代码
}
```
- union
union是C++中的一个关键字，它用于定义联合类型。联合类型是一种特殊的结构体，它的所有成员共用同一块内存空间，只能同时使用其中的一个成员。union关键字可以用于联合类型的定义中。例如：
```
union MyUnion {
int n;
float f;
char c;
};
```
- unsigned
unsigned是C++中的一个关键字，它用于指示一个整数类型是无符号的。无符号整数类型是一种只包含非负整数的整数类型，它的取值范围比有符号整数类型大一倍。unsigned关键字可以用于整数类型的定义中。例如：
```
unsigned int n = 10; // 声明一个无符号整数类型的变量n，并将其初始化为10
```
- using
using是C++中的一个关键字，它用于定义别名。别名是一种将一个名称定义为另一个名称的方式。using关键字可以用于别名的定义中。例如：
```
using Integer = int; // 将int类型定义为Integer类型别名
Integer n = 10; // 声明一个Integer类型的变量n，并将其初始化为10
```
- virtual
virtual是C++中的一个关键字，它用于实现多态性。多态性是一种面向对象编程的概念，它允许不同的对象对同一消息做出不同的响应。virtual关键字可以用于类的成员函数的定义中，用于指示该函数是一个虚函数。例如：
```
class Base {
public:
virtual void foo() { // 声明一个虚函数
// 代码
}
};
class Derived : public Base {
public:
void foo() override { // 重写虚函数
// 代码
}
};
```
- void
void是C++中的一个关键字，它用于指示一个函数不返回任何值。void关键字可以用于函数的返回类型的定义中。例如：
```
void foo() { // 声明一个不返回任何值的函数
// 代码
}
```
- volatile
volatile是C++中的一个关键字，它用于指示一个变量是易变的。易变变量是一种可能被意外修改的变量，例如，一个多线程程序中的共享变量。volatile关键字可以用于变量的定义中。例如：
```
volatile int n = 10; // 声明一个易变变量n，并将其初始化为10
```
- wchar_t
wchar_t是C++中的一个关键字，它用于表示宽字符类型。宽字符类型是一种用于表示Unicode字符的字符类型，它的大小通常是16位或32位。wchar_t关键字可以用于字符类型的定义中。例如：
```
wchar_t c = L'中'; // 声明一个宽字符变量c，并将其初始化为中文字符
```
- while
while是C++中的一个关键字，它用于实现循环结构。循环结构是一种重复执行某个代码块的结构，while关键字可以用于循环结构的定义中。例如：
```
int n = 0;
while (n < 10) { // 声明一个循环结构，直到n的值大于等于10时退出循环
// 代码
++n;
}
```
到此关于C++关键字的总结终于完毕。
其他C++知识点可以参考:
C++进阶：https://blog.csdn.net/zhouruifu2015/category_5659847
更多资料 · 微信公众号搜索【CTO Plus】关注后，获取更多，我们一起学习交流。
1350
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
