C++的关键字

1. 基本类型关键字：

   • bool: 表示布尔类型，只能取true或false。
   • char: 表示字符类型，用于存储单个字符。
   • int: 表示整数类型，用于存储整数值。
   • double: 表示双精度浮点数类型，用于存储小数值。
   • void: 表示空类型，用于表示没有返回值的函数或指针。

   示例：

   bool isTrue = true;
   char ch = 'A';
   int num = 10;
   double pi = 3.14159;
   void printMessage() { /* 函数体 */ }
   
   
   1
   2
   3
   4
   5
   6
   7

2. 控制流关键字：

   • if: 用于条件判断，根据条件执行相应的代码块。
   • else: 与if配合使用，用于在条件不满足时执行的代码块。
   • switch: 用于多分支条件判断，根据不同的值执行相应的代码块。
   • case: 与switch配合使用，用于定义不同的分支。
   • while: 用于循环执行一段代码，只要条件满足就会一直执行。
   • do: 与while配合使用，用于至少执行一次循环，然后根据条件判断是否继续执行。
   • for: 用于循环执行一段代码，可以在指定的条件下重复执行。
   • break: 用于在循环或switch语句中终止当前的循环或分支。
   • continue: 用于跳过当前循环的剩余代码，继续下一次循环。

   示例：

   int x = 5;
   if (x > 0) {
       // 执行代码块
   } else {
       // 执行代码块
   }
   
   switch (x) {
       case 1:
           // 执行代码块
           break;
       case 2:
           // 执行代码块
           break;
       default:
           // 执行代码块
           break;
   }
   
   for (int i = 0; i < 10; i++) {
       // 执行代码块
   }
   
   
   1
   2
   3
   4
   5
   6
   7
   8
   9
   10
   11
   12
   13
   14
   15
   16
   17
   18
   19
   20
   21
   22
   23
   24

3. 类和对象关键字：

   • class: 用于定义类。
   • struct: 用于定义结构体。
   • private: 用于指定类的私有成员。
   • public: 用于指定类的公有成员。
   • protected: 用于指定类的保护成员。
   • new: 用于在堆上动态分配内存，创建对象。
   • delete: 用于释放动态分配的内存，销毁对象。

   示例：

   class MyClass {
   private:
       int privateVar;
   public:
       void publicMethod() {
           // 执行代码块
       }
   };
   
   struct MyStruct {
       int x;
       int y;
   };
   
   MyClass* obj = new MyClass();
   delete obj;
   
   
   1
   2
   3
   4
   5
   6
   7
   8
   9
   10
   11
   12
   13
   14
   15
   16
   17
   18

4. 修饰符关键字：

   • const: 用于声明常量，表示变量的值不能被修改。
   • static: 用于声明静态变量，该变量在整个程序生命周期内保持存在。
   • inline: 用于声明内联函数，将函数的定义直接插入到调用点处。
   • virtual: 用于声明虚函数，允许在派生类中重写基类的同名函数。
   • explicit: 用于声明显式构造函数，禁止隐式类型转换。

   示例：

class MyClass {
public:
    void printValue() const {
        // 执行代码块
    }
};

static int count = 0;

inline int addNumbers(int a, int b) {
    return a + b;
}

class Base {
public:
    virtual void printMessage() {
        // 执行代码块
    }
};

int main() {
    MyClass obj;
    obj.printValue();

    count++;

    int result = addNumbers(5, 10);
    
    Base* basePtr = new Base();
    basePtr->printMessage();

    delete basePtr;

    return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35

在上面的示例中，定义了一个名为MyClass的类，它包含一个名为printValue的成员函数，该函数带有const修饰符，表示它不会修改类的成员变量。

还定义了一个名为count的静态变量，它在整个程序生命周期内保持存在。

函数addNumbers被声明为inline，这意味着函数的定义将直接插入到调用点处，以提高性能。

Base类具有一个虚函数printMessage，它允许在派生类中重写该函数。

在main函数中，我们创建了一个MyClass对象，并调用了printValue函数。还对count进行了自增操作，并调用了addNumbers函数来执行加法运算。最后，创建了一个Base类的指针，并调用了printMessage函数，然后释放了内存。

5. 类型转换关键字：

   • const_cast: 用于去除const属性，允许对const变量进行非常量操作。
   • dynamic_cast: 用于在继承关系中进行安全的向下转型。
   • reinterpret_cast: 用于进行不同类型之间的强制转换。
   • static_cast: 用于进行静态类型转换，包括基本类型和指针间的转换。

   示例：

   const int x = 5;
   int* y = const_cast<int*>(&x);
   *y = 10; // 修改了const变量的值
   
   class Base {
   public:
       virtual void printMessage() {}
   };
   
   class Derived : public Base {
   public:
       void derivedMethod() {}
   };
   
   Base* basePtr = new Derived();
   Derived* derivedPtr = dynamic_cast<Derived*>(basePtr);
   
   int num = 42;
   double* doublePtr = reinterpret_cast<double*>(&num);
   *doublePtr = 3.14; // 将int类型解释为double类型
   
   int a = 5;
   double b = static_cast<double>(a);
   
   
   1
   2
   3
   4
   5
   6
   7
   8
   9
   10
   11
   12
   13
   14
   15
   16
   17
   18
   19
   20
   21
   22
   23
   24
   25

请注意，以上只是简要示例，展示了修饰符关键字的基本用法。在实际编程中，关键字的使用会根据具体情况和需求而有所不同。