C++ 常用关键字

1. static

控制作用域、生命周期或类成员归属

// 1. 全局/命名空间：仅当前文件可见（避免跨文件重定义）
static int global_static = 10; // 其他文件无法通过 extern 访问

// 2. 局部变量：生命周期延长至程序结束（仅初始化1次）
void counter() {
    static int cnt = 0; 
    cnt++; 
    cout << cnt << " "; // 调用3次输出：1 2 3
}

// 3. 类成员：属于类（所有对象共享），需类外初始化
class Car {
public:
    static int total; // 声明
    static void printTotal() { cout << total << endl; } // 无 this 指针
};
int Car::total = 0; // 必须类外初始化（全局作用域）

注意：类 static 成员函数不能访问非 static 成员（无 this 指针）。

问题：static 关键字的三种用法及区别？

全局 / 命名空间：限制符号仅当前文件可见，解决 “重复定义” 问题。
局部变量：生命周期为程序全程（仅初始化 1 次），作用域仍为函数内（避免全局变量污染）。
类成员：变量属于类（所有对象共享），函数无 this 指针（仅访问 static 成员），需类外初始化。

2. const

声明 “不可修改的常量”，增强类型安全

// 1. 修饰变量：值不可改
const int MAX = 100; 
// MAX = 200; // 错误：const 变量禁止写入

// 2. 修饰指针（两种场景）
const int* p1;    // 指针指向的内容不可改（*p1 = 5 错误）
int* const p2 = &MAX; // 指针本身不可改（p2 = &x 错误）
const int* const p3; // 指针和内容均不可改

// 3. 修饰成员函数：保证不修改非 static 成员（this 变为 const T*）
class A {
    int x = 5;
public:
    void print() const { 
        // x = 10; // 错误：const 函数禁止修改成员
        cout << x << endl; 
    }
};

// 4. 修饰函数参数：防止函数内部修改实参
void func(const string& s) { 
    // s = "new"; // 错误：禁止修改参数
}

问题：const 与 #define 的区别？

维度	`const`	`#define`
类型检查	有（编译器检查类型安全）	无（文本替换，易出错）
作用域	受局部 / 类 / 命名空间限制	从定义到 `#undef` 全局
内存	分配内存（可取地址）	不分配内存（仅替换）
调试	可被调试器识别	替换后无法调试

3. volatile

告知编译器 “变量可能被意外修改”（如硬件、多线程），禁止优化（每次从内存读取）。

volatile int flag = 0; // 可能被其他线程/硬件修改
while (flag == 0) { 
    // 循环等待：每次从内存读 flag（而非寄存器缓存）
}

问题：volatile 与 const 能否同时修饰一个变量？
可以。例如 const volatile int x; 表示：

const：当前代码不能修改 x；
volatile：x 可能被外部（如硬件）修改，每次访问需从内存读取。

4. mutable

允许在 const 成员函数中修改被修饰的成员变量（突破 const 限制）。

class Cache {
private:
    mutable int hit_count = 0; // 可在 const 函数中修改
public:
    int get_data() const {
        hit_count++; // 合法：hit_count 是 mutable
        return 42;
    }
};

5. extern

声明 “外部符号”（定义在其他文件），或指定 C 语言编译规则。

// 1. 声明外部变量（file1.cpp 定义，file2.cpp 使用）
// file1.cpp: int global_val = 100;
extern int global_val; // file2.cpp 声明（无需初始化）

// 2. 调用 C 语言函数（避免 C++ 名称修饰）
extern "C" {
    #include "c_library.h" // C 头文件（如 printf）
}

6. thread_local（C++11+）

定义 “线程局部变量”（每个线程有独立副本，生命周期与线程一致）

#include <thread>
thread_local int thread_id = 0; // 每个线程有独立的 thread_id

void worker(int id) {
    thread_id = id; 
    cout << "Thread " << thread_id << endl; // 每个线程输出自己的 id
}

int main() {
    thread t1(worker, 1);
    thread t2(worker, 2);
    t1.join(); t2.join(); // 输出：Thread 1 \n Thread 2
}

7. class vs struct

均用于定义类，核心区别是默认访问权限和继承方式。

class A { 
    int x; // 默认 private（仅类内访问）
};
struct B { 
    int y; // 默认 public（外部可直接访问）
};

// 继承权限区别
class C : A { ... }; // 继承默认 private（A 的 public 成员变为 C 的 private）
struct D : B { ... }; // 继承默认 public（B 的 public 成员仍为 D 的 public）

问题：class 和 struct 的核心区别？

默认成员权限：class 默认为 private，struct 默认为 public。
默认继承权限：class 继承默认为 private，struct 继承默认为 public。
语义习惯：struct 多用于 “数据聚合”（如 POD 类型，无复杂行为），class 多用于 “封装对象”（含成员函数和状态管理）。

8. enum vs enum class（C++11+）

定义枚举类型，enum class 是 “强类型枚举”（更安全）。

// 传统 enum：作用域全局，可隐式转换为 int（易冲突）
enum Color { RED, GREEN, BLUE };
Color c = RED;
int x = RED; // 隐式转换（不推荐）

// enum class（强类型）：作用域受限，无隐式转换（推荐）
enum class Direction { LEFT, RIGHT };
Direction d = Direction::LEFT; // 必须用 :: 访问
// int y = Direction::LEFT; // 错误：无隐式转换

9. typedef vs using（C++11+）

定义类型别名（简化复杂类型），using 支持模板别名（更灵活）。

// typedef 定义别名
typedef std::vector<int> IntVec;
typedef int (*FuncPtr)(int, int); // 函数指针别名

// using 定义别名（C++11+，支持模板）
using IntVec = std::vector<int>;
template <typename T>
using Ptr = T*; // 模板别名（typedef 无法实现）
Ptr<int> p = new int(10); // 等价于 int* p

10. typename

在模板中声明 “类型名”（区分类型与非类型成员）；
替代 class 作为模板参数关键字。

template <typename T> // 等价于 template <class T>
class MyClass {
    typename T::SubType* ptr; // 声明 T::SubType 是类型（否则编译器视为成员变量）
};

11. 基本数据类型关键字

包括 bool（布尔）、char（字符）、int（整数）、float/double（浮点数）、void（无类型）等，以及扩展类型 short/long（长度修饰）、signed/unsigned（符号修饰）、wchar_t/char8_t/char16_t/char32_t（字符编码）。

bool flag = true;
char c = 'a';
int x = 10;
long long num = 1e18;
unsigned int cnt = 0;
wchar_t wstr[] = L"中文"; // 宽字符
char8_t u8str[] = u8"UTF-8"; // C++20 新增

12. virtual

声明虚函数（实现多态）或虚析构函数（避免内存泄漏）。

class Base {
public:
    virtual void run() { cout << "Base run"; } // 虚函数（可被重写）
    virtual ~Base() { cout << "Base 析构"; }   // 虚析构（确保派生类析构被调用）
};
class Derived : public Base {
public:
    void run() override { cout << "Derived run"; } // 重写虚函数
    ~Derived() override { cout << "Derived 析构"; }
};

Base* obj = new Derived();
obj->run(); // 输出 "Derived run"（多态：运行时绑定）
delete obj; // 先调用 Derived 析构，再 Base 析构（无内存泄漏）

13. override（C++11+）

显式声明 “重写基类虚函数”，编译器检查签名一致性（避免笔误）。

class Base {
public:
    virtual void func(int x) {}
};
class Derived : public Base {
public:
    void func(int x) override {} // 正确：重写 Base::func
    // void func(double x) override {} // 错误：参数类型不匹配（编译器报错）
};

14. final

禁止类被继承或虚函数被重写。

class FinalClass final {}; // 禁止被继承
// class Sub : public FinalClass {}; // 错误

class Base {
public:
    virtual void stop() final {} // 禁止重写
};
class Derived : public Base {
    // void stop() override {} // 错误：stop 是 final
};

15. explicit

禁止单参数构造函数的 “隐式转换”（避免意外类型转换）。

class Point {
public:
    explicit Point(int x) : x(x) {} // 禁止隐式转换
private:
    int x;
};
Point p1(10); // 正确：显式构造
// Point p2 = 10; // 错误：explicit 禁止 int→Point 的隐式转换

16. noexcept（C++11+）

声明函数 “不会抛出异常”，帮助编译器优化，避免异常传播。

void func() noexcept { // 声明不抛异常
    // 若函数内抛出异常，会调用 std::terminate()
}
void func2() noexcept(false) { // 声明可能抛异常
    throw std::runtime_error("error");
}

17. constexpr（C++11+）

声明 “编译期常量” 或 “编译期可执行函数”（提升性能）。

constexpr int MAX = 100; // 编译期常量
constexpr int add(int x, int y) { return x + y; }
constexpr int sum = add(3, 5); // 编译期计算，sum=8

问题：const和constexpr的区别？

const表示运行时常量（值可能运行时确定）
constexpr表示编译时常量（值必须编译时确定）
constexpr函数可在编译期执行

posted @ 2025-09-18 16:03 xclic 阅读(65) 评论(0) 收藏举报

刷新页面返回顶部