C++ 关键字完整介绍

文章目录

1. 关键字

2. 控制语句关键字

3. 数据类型关键字

4. 存储类型关键字

5. 类和对象相关关键字

6. 异常处理关键字

7. 其他关键字

---

1. 关键字

C++ 关键字是编程语言保留的单词，这些单词具有特定的含义，并在编译过程中被编译器识别和处理。由于关键字有特殊的用途，因此不能将它们用作标识符（变量名、函数名、类名等）。

• 控制语句关键字：用于控制程序的流程，例如条件判断、循环等。
• 数据类型关键字：用于定义变量和函数的类型。
• 存储类型关键字：用于指定变量的存储位置和生命周期。
• 类和对象相关关键字：用于面向对象编程，定义类、对象及其属性和方法。
• 异常处理关键字：用于处理程序运行时的异常。
• 其他关键字：提供各种其他功能，如命名空间、类型转换等。

分类	关键字	描述
控制语句关键字	if	条件语句，用于根据条件表达式的结果执行代码块。
	else	与if配合使用，用于条件为假时执行代码块。
	switch	用于根据一个变量的值执行不同的代码块。
	case	在switch语句中用于匹配变量的值。
	default	在switch语句中用于处理所有未匹配的情况。
	for	循环语句，用于执行代码块多次，通常用于已知次数的循环。
	while	循环语句，用于根据条件表达式重复执行代码块。
	do	与while配合使用，先执行代码块，再检查条件表达式。
	break	终止循环或switch语句，并跳出语句块。
	continue	跳过当前循环迭代，继续下一次迭代。
	goto	无条件跳转到标记位置，不推荐使用，因为会使代码难以维护。
	return	用于从函数中返回值，并终止函数执行。
数据类型关键字	int	整数类型。
	float	单精度浮点数类型。
	double	双精度浮点数类型。
	char	字符类型。
	void	无类型，常用于函数无返回值。
	bool	布尔类型，表示真或假。
	short	短整数类型，通常为16位。
	long	长整数类型，通常为32位或更长。
	signed	有符号类型修饰符。
	unsigned	无符号类型修饰符。
	wchar_t	宽字符类型，通常用于Unicode字符。
存储类型关键字	auto	自动类型推断，C++11 引入。
	register	建议将变量存储在寄存器中，实际使用由编译器决定。
	static	指定变量在其作用域内保持其值和生命周期。
	extern	声明变量或函数在另一个文件中定义。
	mutable	允许常量成员在const成员函数中被修改。
	thread_local	声明线程局部存储变量，每个线程有其独立实例。
类和对象相关关键字	class	定义类。
	struct	定义结构体，默认访问权限为公有。
	union	定义共用体。
	this	指针，指向调用对象自身。
	public	访问权限，公有成员。
	private	访问权限，私有成员。
	protected	访问权限，受保护成员。
	virtual	声明虚函数，支持多态。
	friend	声明友元，允许非成员函数访问私有和保护成员。
	explicit	显式构造函数，防止隐式转换。
	new	动态分配内存。
	delete	释放动态分配的内存。
	operator	重载运算符。
	sizeof	计算对象或类型的字节大小。
	typename	声明类型名称，特别是在模板中使用。
异常处理关键字	try	用于捕获异常。
	catch	用于处理异常。
	throw	用于抛出异常。
其他关键字	namespace	定义命名空间，用于组织代码，避免命名冲突。
	using	引入命名空间或类型别名。
	inline	建议编译器内联函数，减少函数调用开销。
	const	声明常量或常量成员函数。
	volatile	指示变量可能会被程序外因素修改，防止编译器优化。
	enum	定义枚举类型。
	typedef	为现有类型定义新的名称。
	template	定义模板，用于泛型编程。
	constexpr	用于在编译时计算常量表达式。
	nullptr	空指针常量，取代旧的NULL。
	dynamic_cast	用于安全地将基类指针转换为派生类指针。
	static_cast	用于执行显式转换。
	reinterpret_cast	用于重新解释类型的比特模式。
	const_cast	用于移除const或volatile属性。
	typeid	用于在运行时获取对象的类型信息。
	export	用于模板导出，C++20之前被弃用，现已被删除。
	import	用于模块导入，C++20引入。

2. 控制语句关键字

if：条件语句，用于根据条件表达式的结果执行代码块。

if (condition) {
    // code to execute if condition is true
}

else：与if配合使用，用于条件为假时执行代码块。

if (condition) {
    // code if condition is true
} else {
    // code if condition is false
}

switch：用于根据一个变量的值执行不同的代码块。

switch (variable) {
    case value1:
        // code for value1
        break;
    case value2:
        // code for value2
        break;
    default:
        // default code
}

case：在switch语句中用于匹配变量的值。

switch (variable) {
    case value:
        // code for case value
        break;
}

default：在switch语句中用于处理所有未匹配的情况。

switch (variable) {
    default:
        // default code
}

for：循环语句，用于执行代码块多次，通常用于已知次数的循环。

for (int i = 0; i < 10; i++) {
    // code to execute
}

while：循环语句，用于根据条件表达式重复执行代码块。

while (condition) {
    // code to execute
}

do：与while配合使用，先执行代码块，再检查条件表达式。

do {
    // code to execute
} while (condition);

break：终止循环或switch语句，并跳出语句块。

for (int i = 0; i < 10; i++) {
    if (i == 5) {
        break;
    }
}

continue：跳过当前循环迭代，继续下一次迭代。

continue：跳过当前循环迭代，继续下一次迭代。

goto：无条件跳转到标记位置，不推荐使用，因为会使代码难以维护。

goto label;
// code
label:
// code to execute after jump

return：用于从函数中返回值，并终止函数执行。

int function() {
    return value;
}

3. 数据类型关键字

int：整数类型。

int number = 10;

float：单精度浮点数类型。

float number = 3.14;

double：双精度浮点数类型。

double number = 3.1415926535;

char：字符类型。

char letter = 'A';

void：无类型，常用于函数无返回值。

void function() {
    // code
}

bool：布尔类型，表示真或假。

bool isTrue = true;

short：短整数类型，通常为16位。

short number = 32767;

long：长整数类型，通常为32位或更长。

long number = 2147483647;

signed：有符号类型修饰符。

signed int number = -10;

unsigned：无符号类型修饰符。

unsigned int number = 10;

wchar_t：宽字符类型，通常用于Unicode字符。

wchar_t wideChar = L'A';

4. 存储类型关键字

auto：自动类型推断，C++11 引入。

auto number = 10; // 编译器推断number为int类型

register：建议将变量存储在寄存器中，实际使用由编译器决定。

register int number = 10;

static：指定变量在其作用域内保持其值和生命周期。

static int count = 0;

extern：声明变量或函数在另一个文件中定义。

extern int number;

mutable：允许常量成员在const成员函数中被修改。

class MyClass {
    mutable int var;
public:
    void modify() const {
        var = 10;
    }
};

thread_local：声明线程局部存储变量，每个线程有其独立实例。

thread_local int number = 10;

5. 类和对象相关关键字

class：定义类。

class MyClass {
    int var;
public:
    void method();
};

struct：定义结构体，默认访问权限为公有。

struct MyStruct {
    int var;
};

union：定义共用体。

union MyUnion {
    int intVar;
    float floatVar;
};

this：指针，指向调用对象自身。

class MyClass {
    int var;
public:
    void setVar(int var) {
        this->var = var;
    }
};

public：访问权限，公有成员。

class MyClass {
public:
    int var;
};

private：访问权限，私有成员。

class MyClass {
private:
    int var;
};

protected：访问权限，受保护成员。

class MyClass {
protected:
    int var;
};

virtual：声明虚函数，支持多态。

class Base {
public:
    virtual void display();
};

friend：声明友元，允许非成员函数访问私有和保护成员。

class MyClass {
    friend void myFriendFunction(MyClass &obj);
private:
    int var;
};

explicit：显式构造函数，防止隐式转换。

class MyClass {
public:
    explicit MyClass(int var);
};

new：动态分配内存。

int* ptr = new int;

delete：释放动态分配的内存。

delete ptr;

operator：重载运算符。

class MyClass {
public:
    MyClass operator+(const MyClass &obj);
};

sizeof：计算对象或类型的字节大小。

int size = sizeof(int);

typename：声明类型名称，特别是在模板中使用。

template <typename T>
class MyClass {
    T var;
};

6. 异常处理关键字

try：用于捕获异常。

try {
    // code that may throw an exception 可能抛出异常的代码
}

catch：用于处理异常。

try {
    // code that may throw an exception 可能抛出异常的代码
} catch (const std::exception &e) {
    // code to handle the exception  处理异常的代码
} 

throw：用于抛出异常。

throw std::runtime_error("Error occurred");

7. 其他关键字

namespace：定义命名空间，用于组织代码，避免命名冲突。

namespace MyNamespace {
    int var;
}

using：引入命名空间或类型别名。

using namespace MyNamespace;
using MyAlias = MyClass;

inline：建议编译器内联函数，减少函数调用开销。

inline void myFunction() {
    // code
}

const：声明常量或常量成员函数。

const int var = 10;
void myFunction() const;

volatile：指示变量可能会被程序外因素修改，防止编译器优化。

volatile int var;

enum：定义枚举类型。

enum Color { RED, GREEN, BLUE };

typedef：为现有类型定义新的名称。

typedef int myInt;

template：定义模板，用于泛型编程。

template <typename T>
class MyClass {
    T var;
};

constexpr：用于在编译时计算常量表达式。

constexpr int square(int x) {
    return x * x;
}

nullptr：空指针常量，取代旧的NULL。

int* ptr = nullptr;

dynamic_cast：用于安全地将基类指针转换为派生类指针。

Derived* d = dynamic_cast<Derived*>(basePtr);

static_cast：用于执行显式转换。

int i = static_cast<int>(3.14);

reinterpret_cast：用于重新解释类型的比特模式。

int* p = reinterpret_cast<int*>(ptr);

const_cast：用于移除const或volatile属性。

const int* ptr = &value;
int* modifiablePtr = const_cast<int*>(ptr);

typeid：用于在运行时获取对象的类型信息。

typeid(obj).name();

import：用于模块导入，C++20引入。

import module_name;