C++的关键字（保留字）完整介绍

C++ Keywords

保留字(关键字)

C++系统中预定义的、在语言或编译系统的实现中具有特殊含义的单词:

if	else	while	signed	throw	union	this
int	char	double	unsigned	const	goto	virtual
for	float	break	auto	class	operator	case
do	long	typedef	static	friend	template	default
new	void	register	extern	return	enum	inline
try	short	continue	sizeof	switch	private	protected
asm	while	catch	delete	public	volatile	struct

以下是对上述C++关键字的解释：

1. asm（汇编指令）

asm允许在C++程序中直接嵌入汇编代码。
用法场景：需要执行底层硬件相关的指令时，可以使用它。

2. auto（自动存储类型）

auto用来声明变量的存储类型是“自动的”，这意味着变量的生命周期受限于它所在的代码块（比如函数、循环等）。
通常可以省略，因为这是默认行为。

3. bool（布尔类型）

bool表示“真或假”的值。
有两个有效值：true（真）和false（假）。
示例：bool isActive = true;
在条件判断中很常用，比如if语句。

4. break（跳出语句）

break用于终止循环或退出switch语句。
当程序遇到break时，会直接跳到代码块的外面继续执行。
示例：在for循环中提前停止迭代。

5. case（条件分支）

case用在switch语句中，表示不同的条件。

示例：

switch (x) {
    case 1:
        // 如果 x 是 1，执行这里的代码
        break;
    case 2:
        // 如果 x 是 2，执行这里的代码
        break;
}

6. catch（异常捕获）

catch和try配合使用，用于处理程序运行时的异常。

示例：

try {
    // 可能抛出异常的代码
} catch (std::exception& e) {
    // 捕获异常并处理
}

7. char（字符类型）

char表示一个字符，比如字母或符号。
数据范围是0到255，对应ASCII码表的值。
示例：char letter = 'A';

8. class（类）

class是C++面向对象编程的核心，用来定义对象的模板或蓝图。
类中可以包含属性和方法，用于模拟现实世界中的事物。

示例：

class Car {
    public:
        string brand;
        void drive() {
            // 驾驶行为
        }
};

9. `const`（常量）

const表示“不可更改”。
用const修饰的变量或对象，其值在程序运行中不能被改变。

示例：

1	const double pi = 3.14159; // pi 是一个常量，不能修改

修饰函数：
如果const修饰一个函数，则该函数不能修改外部变量，也不能调用非const函数。
示例：

class MyClass {
    int value;
public:
    int getValue() const { return value; } // getValue不能修改任何变量
};

优点：
相较于#define，const不仅可以定义常量，还具有类型检查功能，使用更安全。

10. `const_cast`（类型转换运算符）

const_cast用来去除const属性，允许对原本不可修改的对象进行更改。

示例：

1
2
3

const int x = 42;
int* px = const_cast<int*>(&x); // 去掉 x 的 const 性质
*px = 100;                     // 修改 x 的值

注意：使用const_cast需要小心，错误的使用可能导致程序未定义行为。

11. `continue`（跳过当前循环）

continue用在循环中，跳过本次循环剩下的代码，直接开始下一次循环。
与break的区别：
- break会结束整个循环。
- continue只跳过当前循环的后续部分，继续执行下一次循环。

示例：

for (int i = 0; i < 5; i++) {
    if (i == 2) continue; // 跳过 i == 2 的情况
    std::cout << i << std::endl;
}
// 输出：0 1 3 4

12. `default`（默认分支）

default是switch语句中的默认分支。
当所有的case条件都不满足时，执行default部分的代码。

示例：

int x = 10;
switch (x) {
    case 5:
        std::cout << "x is 5" << std::endl;
        break;
    case 8:
        std::cout << "x is 8" << std::endl;
        break;
    default:
        std::cout << "x is something else" << std::endl;
}
// 输出：x is something else

注意：default是可选的，可以没有。

13. `delete`（释放内存）

delete用于释放通过new关键字动态分配的内存空间。
释放的对象可以是单个变量或数组，但必须与分配时的形式匹配。

示例：

int* ptr = new int(5);  // 动态分配一个整数
delete ptr;             // 释放内存

int* arr = new int[10]; // 动态分配一个数组
delete[] arr;           // 释放数组

注意：释放内存后不能再次使用，否则会导致“悬空指针”。

14. `do`（循环结构）

do是do-while循环的一部分，与while循环类似，但它至少执行一次循环体，因为条件是在循环体执行之后才检查的。

示例：

int i = 0;
do {
    std::cout << "i is " << i << std::endl;
    i++;
} while (i < 3);

输出：
1
2
3
i is 0
i is 1
i is 2

15. `double`（双精度浮点数）

double是C++中表示浮点数的一种数据类型，用于存储带小数点的数值，精度比float更高。

示例：

1 2	double pi = 3.14159; std::cout << "Pi is " << pi << std::endl;

通常用于需要更高精度的数学计算。

16. `dynamic_cast`（动态类型转换）

dynamic_cast用于在运行时将基类指针或引用转换为派生类指针或引用，确保类型安全。
适用于有继承关系的类之间的转换。

示例：

class Base {
    virtual void func() {}  // 必须有虚函数
};

class Derived : public Base {};

Base* basePtr = new Derived();
Derived* derivedPtr = dynamic_cast<Derived*>(basePtr);
if (derivedPtr) {
    std::cout << "Conversion successful!" << std::endl;
} else {
    std::cout << "Conversion failed!" << std::endl;
}

注意：
- 如果转换失败，返回nullptr（对于指针）或抛出异常（对于引用）。

17. `else`（条件分支）

else和if配合使用，用于处理if条件为false时的操作。

示例：

int x = 10;
if (x > 0) {
    std::cout << "x is positive" << std::endl;
} else {
    std::cout << "x is non-positive" << std::endl;
}

输出：
1
x is positive

enum（枚举）
enum（枚举）类型用于定义一组固定的值，值的选择只能在这些预定义的选项中进行。例如，你可以使用枚举类型来表示一周的七天，每天对应一个固定的值：Monday, Tuesday, Wednesday, Thursday, Friday, Saturday, Sunday。每个枚举值都代表一个常量，确保只能选择这些特定的值。

explicit（显式的）
explicit关键字的作用是“禁止单参数构造函数”在自动类型转换中被使用。简单来说，它防止编译器在进行类型转换时，自动将一个类型转换成这个构造函数的类型。例如，某些容器类型的构造函数可能接收一个数字作为初始大小，如果没有explicit，那么编译器可能会错误地将一个整数自动转换成容器类型。通过显式标记构造函数，可以避免这种自动转换。

export（导出）
当你想访问其他代码文件中的变量或对象时，如果是普通类型（如基本数据类型、结构体或类），可以使用extern来引用。但是对于模板类型（如模板类或模板函数），你需要使用export来声明它们。在这种情况下，export告诉编译器这些模板是为了在其他文件中使用而被定义的。

extern（外部的）
extern关键字用于声明一个变量或函数是“外部链接”的，意思是它在其他文件中可以被访问和使用。这意味着这个变量或函数并没有在当前文件中定义，而是在程序的其他部分定义的。使用extern声明的变量或函数会在程序开始时分配空间，结束时释放。它们的定义应该出现在其他文件或同一文件的其他地方。如果要使用其他语言编写的代码，可以用extern "C"来声明，指明用C语言的方式进行链接。

false（假的）
false是C++中布尔类型（bool）的一个值，表示“假”。它等价于整数类型中的0。在C++中，bool类型的变量可以是true（真）或false（假）。

float（浮点数）
float是C++中的一种数据类型，用于表示小数（浮点数）。它的精度比double低，适用于对精度要求不高的情况。比如，如果你只需要表示一位小数，使用float可以节省内存。

for（循环）
for是C++中的一种循环结构，用来反复执行一段代码，直到满足特定的条件为止。通常用于已知需要循环多少次的场景。例如，遍历数组或从1加到10。

friend（友元）
friend关键字用来声明友元关系，它允许其他函数或类访问当前类的私有（private）和保护（protected）成员。通过友元，某些函数或类可以直接操作本应隐藏的成员，从而提高效率或简化代码。友元可以是函数、类或特定的成员函数。

goto（转到）
goto是C++中的一种语句，用于跳转到程序中的另一个位置。虽然它可以改变程序的执行流，但通常不推荐使用，因为它会让程序的逻辑变得混乱。现代编程中，常用其他控制流结构（如for、while、if等）来替代goto。

if（如果）
if是C++中的条件语句，用于判断某个条件是否为真。如果条件为真，程序就会执行相应的代码块；如果为假，则跳过这个代码块。它是实现程序决策和分支逻辑的基础。

inline（内联函数）
inline用于定义内联函数，即编译器在调用该函数时，将函数的代码直接插入调用处，而不是进行常规的函数调用。内联函数通常很小，且频繁调用，使用inline可以提高程序执行效率，减少函数调用的开销。

int（整型）
int是C++中的基本数据类型，用来表示整数（没有小数的数）。它的范围通常较小，比long类型的整数范围要窄一些。

long（长整型）
long是C++中的另一种整型数据类型，用来表示比int类型范围更大的整数。它可以存储更大的数值。

mutable（易变的）
mutable是C++中的一个特殊关键字，通常用于类中的成员变量。它允许即使在const函数中，也可以修改被声明为mutable的成员变量。换句话说，它让类的常量成员函数能够修改某些成员变量，这通常用于需要记录某些信息但又不能改变对象状态的情况。

namespace（命名空间）
namespace用于组织和区分类。它是一种比类更大的组织结构，允许你将不同的类、函数等进行分组，避免命名冲突。你可以把它看作一个容器，帮助管理代码。

new（新建）
new是C++中的一个运算符，用于动态创建对象。它会在内存中为对象分配空间，并返回指向该对象的指针。也就是说，new会返回一个指向新创建对象的指针。

operator（操作符）
operator用于操作符重载，它让你可以为C++中的操作符（比如加号、减号等）定义自定义的行为。通过操作符重载，你可以让这些操作符在你的类对象上起作用。

private（私有的）
private是C++中的访问控制符之一，表示一个类的成员（如变量和函数）只能在该类的内部或者其友元类中访问。外部代码不能直接访问这些私有成员。

protected（受保护的）
protected也是C++中的访问控制符之一。被protected标记的成员只能在当前类、派生类（继承的类）以及友元类中访问。外部代码无法直接访问这些受保护的成员。

public（公有的）
public是C++中的访问控制符之一，表示一个类的成员可以被任何代码访问。它没有访问限制，可以在类的外部直接访问这些公有成员。

register（寄存器）
register是C++中的一个关键字，表示请求编译器将某个变量存放在CPU的寄存器中（而不是内存中），以提高访问速度。这个优化仅适用于局部变量，但在现代编译器中，它通常会根据实际情况自动优化，因此在32位编译器中作用较小。

reinterpret_cast（重新解释转换）
reinterpret_cast是C++中的一种类型转换，它可以把一个类型转换成完全不同的另一个类型。例如，它可以把指针转换成整数，或者把整数转换成指针。它的作用是直接重解释数据的二进制表示，而不考虑数据的实际类型，因此需要谨慎使用。

return（返回）
return关键字用于从函数中返回一个值，并结束函数的执行。一旦程序执行到return语句，函数会立即返回结果，之后的代码不会再执行。

short（短整型）
short是C++中的一种整型数据类型，用于表示比int类型范围小的整数。它占用的内存空间比int小，适用于存储较小范围的整数。

signed（有符号）
signed表示数字类型（如整型）是有符号的，也就是说它可以表示正数和负数。与之相对的是unsigned，即无符号类型，表示只有正数和零。大多数数值类型默认就是signed，所以通常不需要显式声明。

sizeof（大小）
sizeof是一个运算符，用来获取数据类型占用的内存大小（以字节为单位）。由于不同系统和编译器可能会有不同的内存分配，使用sizeof可以确保程序的可移植性。

static（静态的）
static关键字用于声明静态变量或静态函数。静态变量在程序开始时分配内存，并且在程序结束时释放。它的作用范围限于定义它的文件或类，在其他文件中不可访问。对于类的静态成员，它是由类的所有实例共享的，所有对象共享同一个静态变量。静态成员变量必须在类外部进行初始化。

好的，下面是这些概念的更简洁易懂的解释：

static_cast（静态转换）
static_cast是C++中的一种类型转换方式，它把表达式转换为指定的类型。它没有运行时的类型检查，所以开发者需要确保转换是安全的。常见的用法包括：

类层次转换：在继承关系中，可以将子类指针/引用转换为基类类型（安全），也可以把基类转换为子类（不安全，因为没有检查）。
基本类型转换：在不同基本类型之间转换，比如int转换为char或枚举类型。
空指针转换：可以将空指针转换为其他类型的空指针。
转换为void类型：可以将任何类型转换为void，用于不返回任何内容。

需要注意的是，static_cast无法移除const、volatile或__unaligned属性。

struct（结构体）
struct是C++中用于定义结构体的一种数据类型，与class类似，但与C语言兼容。它可以用来定义面向对象的程序，且所有成员默认是公有的（public），在实现上类似于class。

switch（选择）
switch是C++中的一种条件语句，用于在多个可能的分支中选择执行一条。它的用法类似于if-else链，但更简洁。switch的条件表达式必须是整型（如int或char）。switch语句通常包括一个可选的default分支，以处理没有匹配的情况。

template（模板）
template是C++中实现泛型编程的关键字。通过模板，可以定义适用于多种数据类型的通用函数或类，使代码更灵活、可重用。

this
this是C++中的一个指针，用于指向当前对象，也就是正在调用该成员函数的对象本身。通过this，对象可以访问它自己的数据成员和其他成员函数。

throw（抛出）
throw关键字用于C++中的异常处理。当程序遇到错误情况时，可以使用throw来抛出一个异常，通知调用者出错。throw的值可以是任意类型的异常对象。

true（真的）
true是C++中布尔类型（bool）的一个值，表示“真”，等价于整数的非零值。布尔类型bool的值可以是true或false。

try（尝试）
try是C++异常处理机制的一部分。它用于包围可能会抛出异常的代码块，并与catch语句搭配使用，以捕获并处理异常。

typedef（类型定义）
typedef用于为已有数据类型创建一个新的别名。例如，可以用typedef给int类型取一个新的名字。这样可以使代码更易读，但并不会创建新的数据类型。

typeid
typeid用于在运行时获得某个对象或指针的实际类型（比如某个指针或引用指向的派生类型），常用于了解继承关系中的具体类型信息。

typename（类型名）
typename关键字告诉编译器，某个名称代表的是一种类型。主要用于模板代码中，以便让编译器正确地理解该名称的含义，尤其当该名称嵌套在其他类型中或依赖于模板参数时。

union（联合体）
union是一种数据结构，允许存储不同类型的数据，但同一时刻只存储一种。所有成员共享同一段内存，大小取决于最大的数据成员。这与enum不同，enum只能用于整数类型。

unsigned（无符号）
unsigned表示无符号类型，只能存储非负数。与signed（有符号）相对，unsigned省去了负数部分，使得同样的空间可以存储更大的正数。

using
using用于简化命名空间的引用。通过using声明，可以直接使用某命名空间的内容，而不必每次都写命名空间前缀。

virtual（虚函数）
virtual用于实现多态性，允许在基类中声明虚函数，从而可以在派生类中实现不同的行为。这样，通过基类指针或引用调用函数时，会执行派生类中的实际实现。

void（空）
void是一种特殊类型，表示“没有类型”或“空”。它可以用于：

函数返回类型：表示函数不返回值。
函数参数：表示没有参数传入。
指针类型：void*表示一个通用指针，可以指向任意类型的数据。

volatile（易变的）
volatile用于标记变量的值可能会随时被系统或其他进程修改，防止编译器对它进行优化。常用于异步处理，如中断程序中涉及的变量。

wchar_t（宽字符）
wchar_t是一种数据类型，用于表示宽字符（即多字节字符）。每个wchar_t占用两个字节，适合表示Unicode字符，例如汉字。

保留字(关键字)

1. asm（汇编指令）

2. auto（自动存储类型）

3. bool（布尔类型）

4. break（跳出语句）

5. case（条件分支）

6. catch（异常捕获）

7. char（字符类型）

8. class（类）

9. const（常量）

10. const_cast（类型转换运算符）

11. continue（跳过当前循环）

12. default（默认分支）

13. delete（释放内存）

14. do（循环结构）

15. double（双精度浮点数）

16. dynamic_cast（动态类型转换）

17. else（条件分支）