C++修饰符类型

一、存储类运算符

auto（自动存储类，但在现代C++中，它通常用于自动类型推导）

register（建议编译器将变量存储在寄存器中，但现代编译器通常忽略此关键字）

static（静态存储类，用于局部变量、全局变量、函数和类成员）

extern（用于声明在其他地方定义的变量或函数）

mutable（允许在const类的非常量成员函数中修改成员变量）

thread_local（C++11引入，用于声明变量的生命周期与线程相同）

二、类型修饰符

const（常量，不可修改）

volatile（告诉编译器不要优化对该变量的访问，因为它可能在程序外部被修改）

signed 和 unsigned（用于整数类型，表示数值的符号属性）

long 和 short（用于调整整数类型的大小）

explicit（用于构造函数，防止不希望的隐式类型转换）

三、访问修饰符（在类中）

public（成员可以被任何代码访问）

protected（成员可以被类的成员函数、友元函数或派生类访问）

private（成员只能被类的成员函数和友元函数访问）

四、作用域解析运算符

::（作用域解析运算符，用于指定类、命名空间或其他作用域中的成员）

五、函数修饰符

inline（建议编译器内联函数，即将函数调用替换为函数体，以减少函数调用的开销）

virtual（在基类中声明，允许派生类覆盖该函数）

override（C++11引入，确保成员函数确实覆盖了基类中的虚函数）

final（C++11引入，禁止类被继承，或禁止虚函数在派生类中被覆盖）

noexcept（C++11引入，指定函数不会抛出异常）

六、模板修饰符

template（用于声明模板类、模板函数等）

七、友元修饰符

friend（声明友元函数或友元类，这些函数或类可以访问类的私有和保护成员）

举个例子

//访问修饰符
class MyClass {  
public:  
    int publicVar;  
protected:  
    int protectedVar;  
private:  
    int privateVar;  
};  
  
int main() {  
    MyClass obj;  
    obj.publicVar = 10; // 访问 public 成员  
    // obj.protectedVar = 20; // 错误：无法从类外部直接访问 protected 成员  
    // obj.privateVar = 30; // 错误：无法从类外部直接访问 private 成员  
    return 0;  
}

//存储修饰符
class MyClass {  
public:  
    static int staticVar; // 静态成员变量  
};  
  
int MyClass::staticVar = 0; // 静态成员变量需要在类外部定义  
  
void function() {  
    extern int globalVar; // 声明外部变量  
    // ... 假设 globalVar 在其他地方已定义  
  
    register int regVar; // register 修饰符在现代编译器中通常被忽略  
  
    const class WithConst {  
    public:  
        mutable int mutVar; // 可变的成员变量，可以在 const 成员函数中被修改  
    } obj;  
    const WithConst* constPtr = &obj;  
    constPtr->mutVar = 5; // 可以在 const 成员函数外通过非 const 指针修改 mutable 成员  
}  
  
// thread_local 示例  
thread_local int tlsVar = 0; // 每个线程都有自己的 tlsVar 副本

//类型修饰符
const int constVar = 10; // 不可变的整数  
volatile int volVar; // 可能被外部因素（如硬件）改变的整数  
signed int signedInt = -5; // 有符号整数  
unsigned int unsignedInt = 5; // 无符号整数  
short shortVar = 100; // 短整数  
long longVar = 1000000000; // 长整数  
float floatVar = 3.14f; // 单精度浮点数  
double doubleVar = 3.141592653589793; // 双精度浮点数  
long double longDoubleVar = 3.141592653589793238L; // 扩展双精度浮点数

//函数修饰符
class Base {  
public:  
    virtual void virtualFunc() { /* ... */ } // 虚函数  
};  
  
class Derived : public Base {  
public:  
    void virtualFunc() override { /* ... */ } // 重写虚函数并使用 override 修饰符  
};  
  
class FinalClass final { // 使用 final 修饰符的类，不能被继承  
public:  
    void finalFunc() final { /* ... */ } // 使用 final 修饰符的函数，不能被重写  
};  
  
class NoImplicitConv {  
public:  
    explicit NoImplicitConv(int x) : value(x) {} // 构造函数使用 explicit 修饰符，防止隐式转换  
private:  
    int value;  
};  
  
void noExceptFunc() noexcept { // 声明函数不会抛出异常  
    // ...  
}

//其他
constexpr int constexprVar = 10; // 编译时常量  
alignas(double) char alignedArray[sizeof(double) * 10]; // 强制对齐的数组