C++关键字大全总结

C++11之前关键字

基本类型关键字

1. int：声明整数类型。

   int num = 42;
   

2. char：声明字符类型。

   char c = 'A';
   

3. float：声明单精度浮点数。

   float f = 3.14f;
   

4. double：声明双精度浮点数。

   double d = 3.14159;
   

5. bool（C++98 引入）：声明布尔类型（true/false）。

   bool flag = true;
   

6. void：表示无类型，用于函数返回值或指针。

   void func();
   void* ptr;
   

7. wchar_t：宽字符类型（用于 Unicode 字符）。

   wchar_t wc = L'あ';
   

---

类型修饰符

1. signed：声明有符号类型（默认修饰符）。

   signed int num = -10;
   

2. unsigned：声明无符号类型。

   unsigned int count = 100;
   

3. short：声明短整型（比 int 更小）。

   short s = 32767;
   

4. long：声明长整型或双精度浮点型。

   long l = 100000L;
   long double ld = 3.1415926535L;
   

---

流程控制

1. if/else：条件分支。

   if (x > 0) { /*...*/ } else { /*...*/ }
   

2. switch/case/default：多分支选择。

   switch (value) {
       case 1: break;
       default: break;
   }
   

3. for：循环结构。

   for (int i=0; i<10; ++i) { /*...*/ }
   

4. while：条件循环。

   while (cond) { /*...*/ }
   

5. do：后测试循环。

   do { /*...*/ } while (cond);
   

6. break：跳出循环或 switch。

7. continue：跳过当前循环迭代。

8. goto：跳转到标签（慎用）。

   goto label;
   label: /*...*/
   

9. return：函数返回值。

   return 42;
   

---

存储类说明符

1. auto（C++11 前）：声明自动存储期的变量（局部变量默认）。

   auto int x = 10; // C++11 前有效
   

2. static：

   • 函数内：静态局部变量（生命周期延长）。
   • 类内：静态成员变量/函数。
   • 全局：限制作用域到当前文件。

   static int count = 0; // 文件作用域
   

3. extern：声明外部链接的变量或函数。

   extern int globalVar; // 定义在其他文件
   

4. register（已弃用）：建议编译器将变量存储在寄存器中。

   register int i;
   

5. mutable：允许在 const 成员函数中修改成员变量。

   class A {
       mutable int cache;
       void func() const { cache = 42; } // 合法
   };
   

---

类与面向对象

1. class：定义类。

   class MyClass { /*...*/ };
   

2. struct：定义结构体（默认成员公有）。

   struct Point { int x, y; };
   

3. union：定义联合体（共享内存的成员）。

   union Data { int i; float f; };
   

4. private/protected/public：访问控制修饰符。

   class A {
   private:
       int secret;
   public:
       void func();
   };
   

5. friend：声明友元（允许访问私有成员）。

   class B { friend class C; };
   

6. virtual：声明虚函数或虚基类。

   virtual void func() = 0; // 纯虚函数
   

7. explicit：禁止隐式构造函数转换。

   explicit MyClass(int x) { /*...*/ }
   

8. operator：重载运算符。

   MyClass operator+(const MyClass& rhs);
   

---

异常处理

1. try/catch/throw：异常处理机制。

   try { throw 42; }
   catch (int e) { /*...*/ }
   

---

模板与类型操作

1. template：定义模板。

   template <typename T> class Box { /*...*/ };
   

2. typename：声明模板中的依赖类型。

   template <typename T> void func() {
       typename T::NestedType x; // 必须使用 typename
   }
   

3. typeid（需包含 <typeinfo>）：获取类型信息。

   typeid(int).name();
   

---

类型转换

1. const_cast：移除 const 或 volatile 修饰。

   const int x = 10;
   int* p = const_cast<int*>(&x);
   

2. dynamic_cast：安全的向下转型（需多态类）。

   Base* b = new Derived();
   Derived* d = dynamic_cast<Derived*>(b);
   

3. static_cast：显式类型转换（编译时检查）。

   double d = 3.14;
   int i = static_cast<int>(d);
   

4. reinterpret_cast：低层重新解释位模式（慎用）。

   int* p = reinterpret_cast<int*>(0x1234);
   

---

其他关键字

1. enum：定义枚举类型。

   enum Color { RED, GREEN, BLUE };
   

2. typedef：定义类型别名。

   typedef int Integer;
   

3. using（C++11 前）：引入命名空间或定义类型别名（C++11 扩展用法）。

   using namespace std;
   typedef using MyInt = int; // C++11 起支持
   

4. namespace：定义命名空间。

   namespace MyNS { int x; }
   

5. asm：内联汇编代码（编译器相关）。

   asm("mov eax, 42");
   

6. volatile：禁止编译器优化（变量可能被外部修改）。

   volatile int sensorValue;
   

7. sizeof：获取类型或对象的大小。

   sizeof(int); // 4（取决于平台）
   

8. new/delete：动态内存分配与释放。

   int* p = new int(42);
   delete p;
   

9. this：指向当前对象的指针。

   void MyClass::func() { this->x = 42; }
   

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

    const int MAX = 100;
    void func() const; // 常量成员函数
    

11. export（C++03 存在但极少支持）：导出模板定义。

    export template <typename T> class A; // 极少使用
    

---

---

C++11

类型推导与类型操作

1. auto（重新定义）：
   自动类型推导（根据初始化表达式推断变量类型）。

   auto x = 42;        // int
   auto s = "hello";   // const char*
   

2. decltype：
   获取表达式的类型，保留 const 和引用修饰。

   int x = 10;
   decltype(x) y = x;   // y 的类型是 int
   decltype((x)) z = x; // z 的类型是 int&
   

3. nullptr：
   明确表示空指针（替代 NULL 宏）。

   int* ptr = nullptr;  // 避免与整数 0 混淆
   

---

常量表达式与编译时计算

1. constexpr：
   声明常量表达式（值或函数在编译时求值）。

   constexpr int square(int x) { return x * x; }
   constexpr int val = square(5);  // 编译时计算
   

2. static_assert：
   编译时断言检查（直接验证条件，无需头文件）。

   static_assert(sizeof(int) == 4, "int must be 4 bytes");
   

---

类与继承控制

1. override：
   显式标记派生类中覆盖基类的虚函数。

   class Base {
       virtual void func();
   };
   class Derived : public Base {
       void func() override;  // 明确表示覆盖
   };
   

2. final：
   禁止类被继承，或虚函数被覆盖。

   class Base final {};       // 类不可继承
   virtual void func() final; // 函数不可覆盖
   

---

移动语义与资源管理

1. noexcept：
   标记函数不会抛出异常（优化与安全）。

   void safe_func() noexcept { /* 保证不抛异常 */ }
   

2. default（新用法）：
   显式生成默认构造函数/赋值函数。

   class MyClass {
       MyClass() = default;  // 强制编译器生成默认构造
   };
   

3. delete（新用法）：
   显式删除函数（禁用特定构造函数或运算符）。

   class NonCopyable {
       NonCopyable(const NonCopyable&) = delete;
   };
   

---

内存对齐与多线程

1. alignas：
   指定变量或类型的对齐方式。

   alignas(16) int arr[4]; // 16 字节对齐
   

2. alignof：
   获取类型的对齐要求。

   int alignment = alignof(double); // 通常是 8
   

3. thread_local：
   声明线程局部存储变量（每个线程独立副本）。

   thread_local int counter = 0; // 每个线程独立
   

---

模板与类型别名

1. using（新用法）：
   替代 typedef 定义类型别名（更清晰的语法）。

   using Vec = std::vector<int>;      // 等价于 typedef
   template<typename T> using Map = std::map<T, T>; // 支持模板
   

---

字面量后缀

1. 用户定义字面量（通过后缀运算符）：

   // 定义自定义字面量
   constexpr long double operator"" _km(long double d) { 
       return d * 1000; 
   }
   double distance = 5.0_km; // 5000 米
   

---

其他新增

1. char16_t/char32_t：
   Unicode 字符类型（UTF-16 和 UTF-32）。

   char16_t c16 = u'字';  // UTF-16
   char32_t c32 = U'字';  // UTF-32
   

2. _Alignas/_Alignof（C11 风格，不推荐使用）：
   同 alignas/alignof，但 C++ 优先使用无下划线的版本。

---

核心语言特性增强

• 右值引用 (&&)：
  支持移动语义和完美转发（虽然不是关键字，但 && 符号是语法的一部分）。

  void func(int&& x);  // 右值引用参数
  

• Lambda 表达式：
  匿名函数（通过 [](){} 语法，无需新关键字）。

  auto add = [](int a, int b) { return a + b; };
  

---

总结

C++11 的关键字和特性使代码更简洁、安全、高效。例如：

• auto 和 decltype 简化了复杂类型的声明。
• nullptr 解决了 NULL 的二义性问题。
• constexpr 将计算移至编译期，提升性能。
• 移动语义（依赖 && 和 noexcept）优化资源管理。

---

特殊值

1. true/false：布尔字面量。
2. NULL（非关键字，但常用）：空指针常量（通常定义为 0）。

---

注意事项

• 部分关键字（如 auto、register）在 C++11 后语义改变或弃用。
• export 在 C++03 中用于模板分离编译，但几乎没有编译器支持。
• mutable 和 explicit 是 C++98 引入的关键字。

---

---

**C++14 **

C++14 未新增任何关键字，仅对现有关键字的功能进行了扩展和优化357。
主要扩展包括：

1. auto

   • 允许用于函数返回值和 Lambda 表达式的参数推导。

     auto func(auto a, auto b) { return a + b; }  // 函数返回值与参数类型自动推导
     auto lambda = [](auto x) { return x * 2; }; // Lambda 参数类型推导
     

2. constexpr

   • 支持更复杂的编译期计算，允许函数内包含局部变量、循环和条件语句（需满足编译期可计算条件）。

     constexpr int factorial(int n) {
         return (n <= 1) ? 1 : n * factorial(n-1);
     }
     

3. decltype

   • 新增 decltype(auto)，保留表达式的引用和常量性。

     int x = 10;
     decltype(x) y = x;          // int 类型
     decltype(auto) z = x;       // int 类型（与 auto 不同，保留原始类型属性）
     

---

---

**C++17 **

C++17 同样未新增关键字，但通过以下扩展显著增强了语言功能268：
主要扩展包括：

1. constexpr 增强

   • 支持 if constexpr，实现编译期条件分支优化，未选择的分支不会生成代码。

     template<typename T>
     void process(T value) {
         if constexpr (std::is_integral_v<T>) { /* 仅编译符合条件的代码 */ }
     }
     

   • 允许 Lambda 表达式在 constexpr 上下文中使用。

     constexpr auto add = [](int a, int b) { return a + b; };
     static_assert(add(2, 3) == 5);  // 编译期计算
     

2. auto 扩展

   • 支持更复杂的类型推导规则，例如结构化绑定（需与 auto 结合使用）。

     std::pair<int, double> p{1, 3.14};
     auto [x, y] = p;  // x 为 int，y 为 double
     

3. inline 变量

   • 允许在头文件中定义全局变量，避免多重定义错误。

     // test.h
     inline int global_num = 42;  // 多文件包含时不会引发链接错误
     

4. typename 扩展

   • 允许在模板模板参数中使用 typename 替代 class（C++17 前仅支持 class）。

     template<template<typename> typename Container>  // C++17 合法
     class MyClass { /* ... */ };
     

---

C++14/17 的新语法特性（基于现有关键字）

1. 结构化绑定（C++17）

   • 使用 auto 解包复合类型（如元组、结构体）。

     std::tuple<int, std::string> t{42, "hello"};
     auto [num, str] = t;  // num=42, str="hello"
     

2. 折叠表达式（C++17）

   • 简化变参模板的参数展开（需结合运算符如 +、*）。

     template<typename... Args>
     auto sum(Args... args) { return (... + args); }  // 右折叠求和
     

3. if 和 switch 的初始化器（C++17）

   • 在条件语句中直接初始化变量。

     if (auto it = m.find(key); it != m.end()) { /* 使用 it */ }
     

---

总结

• C++14：无新增关键字，但扩展了 auto、constexpr 和 decltype 的用法，优化了泛型编程和编译期计算。
• C++17：同样无新增关键字，但通过 if constexpr、结构化绑定和折叠表达式等语法革新，显著提升了代码表达能力和性能268。
• 共同特点：均通过增强现有关键字的功能，减少了对新关键字的依赖，避免破坏向后兼容性。

---

---

C++20 新增关键字

1. concept
   定义类型约束

   template<typename T>
   concept Integral = std::is_integral_v<T>;
   template<Integral T> void func(T t) {}
   

2. requires
   指定模板参数约束

   template<typename T>
   requires std::integral<T>
   T add(T a, T b) { return a + b; }
   

3. constinit
   强制变量在编译期初始化

   constinit static int x = 42; // 编译期初始化
   

4. consteval
   声明函数必须在编译期执行

   consteval int square(int x) { return x * x; }
   int arr[square(3)]; // 必须编译期计算
   

5. co_await / co_return / co_yield
   协程支持

   generator<int> sequence() {
       for (int i = 0; ; ++i) co_yield i;
   }
   

6. char8_t
   UTF-8字符类型

   char8_t c8 = u8'a'; // UTF-8字符
   

7. import / module
   模块系统（替代头文件）

   // math.ixx
   export module math;
   export int add(int a, int b) { return a + b; }
   
   // main.cpp
   import math;
   int result = add(3, 4);
   

总结

• C++20 新增模块、概念、协程等重大特性，进一步简化代码并提升性能。
• 不同版本的关键字和特性需编译器支持（如 GCC/Clang 需开启 -std=c++20）。