1. static
控制作用域、生命周期或类成员归属
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 | // 1. 全局/命名空间：仅当前文件可见（避免跨文件重定义）
staticintglobal_static = 10;// 其他文件无法通过 extern 访问
// 2. 局部变量：生命周期延长至程序结束（仅初始化1次）
voidcounter() {
staticintcnt = 0;
cnt++;
cout << cnt <<" ";// 调用3次输出：1 2 3
}
// 3. 类成员：属于类（所有对象共享），需类外初始化
classCar {
public:
staticinttotal;// 声明
staticvoidprintTotal() { cout << total << endl; }// 无 this 指针
};
intCar::total = 0;// 必须类外初始化（全局作用域）
|
注意：类 static 成员函数不能访问非 static 成员（无 this 指针）。
问题：static关键字的三种用法及区别？
- 全局 / 命名空间：限制符号仅当前文件可见，解决 “重复定义” 问题。
- 局部变量：生命周期为程序全程（仅初始化 1 次），作用域仍为函数内（避免全局变量污染）。
- 类成员：变量属于类（所有对象共享），函数无 this 指针（仅访问 static 成员），需类外初始化。
2. const
声明 “不可修改的常量”，增强类型安全
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 | // 1. 修饰变量：值不可改
constintMAX = 100;
// MAX = 200; // 错误：const 变量禁止写入
// 2. 修饰指针（两种场景）
constint* p1;// 指针指向的内容不可改（*p1 = 5 错误）
int*constp2 = &MAX;// 指针本身不可改（p2 = &x 错误）
constint*constp3;// 指针和内容均不可改
// 3. 修饰成员函数：保证不修改非 static 成员（this 变为 const T*）
classA {
intx = 5;
public:
voidprint()const{
// x = 10; // 错误：const 函数禁止修改成员
cout << x << endl;
}
};
// 4. 修饰函数参数：防止函数内部修改实参
voidfunc(conststring& s) {
// s = "new"; // 错误：禁止修改参数
}
|
问题：const与#define的区别？
| 维度 | const | #define |
|---|
| 类型检查 | 有（编译器检查类型安全） | 无（文本替换，易出错） |
| 作用域 | 受局部 / 类 / 命名空间限制 | 从定义到#undef全局 |
| 内存 | 分配内存（可取地址） | 不分配内存（仅替换） |
| 调试 | 可被调试器识别 | 替换后无法调试 |
3. volatile
告知编译器 “变量可能被意外修改”（如硬件、多线程），禁止优化（每次从内存读取）。
1 2 3 4 | volatileintflag = 0;// 可能被其他线程/硬件修改
while(flag == 0) {
// 循环等待：每次从内存读 flag（而非寄存器缓存）
}
|
问题：volatile与const能否同时修饰一个变量？
可以。例如const volatile int x;表示：
const：当前代码不能修改x；volatile：x可能被外部（如硬件）修改，每次访问需从内存读取。
4. mutable
允许在const成员函数中修改被修饰的成员变量（突破const限制）。
1 2 3 4 5 6 7 8 9 | classCache {
private:
mutableinthit_count = 0;// 可在 const 函数中修改
public:
intget_data()const{
hit_count++;// 合法：hit_count 是 mutable
return42;
}
};
|
5. extern
声明 “外部符号”（定义在其他文件），或指定 C 语言编译规则。
1 2 3 4 5 6 7 | // 1. 声明外部变量（file1.cpp 定义，file2.cpp 使用）
// file1.cpp: int global_val = 100;
externintglobal_val;// file2.cpp 声明（无需初始化）
// 2. 调用 C 语言函数（避免 C++ 名称修饰）
extern"C"{
#include "c_library.h" // C 头文件（如 printf）
}
|
6. thread_local（C++11+）
定义 “线程局部变量”（每个线程有独立副本，生命周期与线程一致）
1 2 3 4 5 6 7 8 9 10 11 | #include <thread>
thread_localintthread_id = 0;// 每个线程有独立的 thread_id
voidworker(intid) {
thread_id = id;
cout <<"Thread "<< thread_id << endl;// 每个线程输出自己的 id
}
intmain() {
threadt1(worker, 1);
threadt2(worker, 2);
t1.join(); t2.join();// 输出：Thread 1 \n Thread 2
}
|
7. class vs struct
均用于定义类，核心区别是默认访问权限和继承方式。
1 2 3 4 5 6 7 8 9 | classA {
intx;// 默认 private（仅类内访问）
};
structB {
inty;// 默认 public（外部可直接访问）
};
// 继承权限区别
classC : A { ... };// 继承默认 private（A 的 public 成员变为 C 的 private）
structD : 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是 “强类型枚举”（更安全）。
1 2 3 4 5 6 7 8 | // 传统 enum：作用域全局，可隐式转换为 int（易冲突）
enumColor { RED, GREEN, BLUE };
Color c = RED;
intx = RED;// 隐式转换（不推荐）
// enum class（强类型）：作用域受限，无隐式转换（推荐）
enumclassDirection { LEFT, RIGHT };
Direction d = Direction::LEFT;// 必须用 :: 访问
// int y = Direction::LEFT; // 错误：无隐式转换
|
9. typedef vs using（C++11+）
定义类型别名（简化复杂类型），using支持模板别名（更灵活）。
1 2 3 4 5 6 7 8 | // typedef 定义别名
typedefstd::vector<int> IntVec;
typedefint(*FuncPtr)(int,int);// 函数指针别名
// using 定义别名（C++11+，支持模板）
usingIntVec = std::vector<int>;
template<typenameT>
usingPtr = T*;// 模板别名（typedef 无法实现）
Ptr<int> p =newint(10);// 等价于 int* p
|
10. typename
- 在模板中声明 “类型名”（区分类型与非类型成员）；
- 替代
class作为模板参数关键字。
1 2 3 4 | template<typenameT>// 等价于 template <class T>
classMyClass {
typenameT::SubType* ptr;// 声明 T::SubType 是类型（否则编译器视为成员变量）
};
|
11. 基本数据类型关键字
包括bool（布尔）、char（字符）、int（整数）、float/double（浮点数）、void（无类型）等，以及扩展类型short/long（长度修饰）、signed/unsigned（符号修饰）、wchar_t/char8_t/char16_t/char32_t（字符编码）。
1 2 3 4 5 6 7 | boolflag =true;
charc ='a';
intx = 10;
longlongnum = 1e18;
unsignedintcnt = 0;
wchar_twstr[] = L"中文";// 宽字符
char8_t u8str[] = u8"UTF-8";// C++20 新增
|
12. virtual
声明虚函数（实现多态）或虚析构函数（避免内存泄漏）。
1 2 3 4 5 6 7 8 9 10 11 12 13 | classBase {
public:
virtualvoidrun() { cout <<"Base run"; }// 虚函数（可被重写）
virtual~Base() { cout <<"Base 析构"; }// 虚析构（确保派生类析构被调用）
};
classDerived :publicBase {
public:
voidrun() override { cout <<"Derived run"; }// 重写虚函数
~Derived() override { cout <<"Derived 析构"; }
};
Base* obj =newDerived();
obj->run();// 输出 "Derived run"（多态：运行时绑定）
deleteobj;// 先调用 Derived 析构，再 Base 析构（无内存泄漏）
|
13. override（C++11+）
显式声明 “重写基类虚函数”，编译器检查签名一致性（避免笔误）。
1 2 3 4 5 6 7 8 9 | classBase {
public:
virtualvoidfunc(intx) {}
};
classDerived :publicBase {
public:
voidfunc(intx) override {}// 正确：重写 Base::func
// void func(double x) override {} // 错误：参数类型不匹配（编译器报错）
};
|
14. final
禁止类被继承或虚函数被重写。
1 2 3 4 5 6 7 8 9 | classFinalClass final {};// 禁止被继承
// class Sub : public FinalClass {}; // 错误
classBase {
public:
virtualvoidstop() final {}// 禁止重写
};
classDerived :publicBase {
// void stop() override {} // 错误：stop 是 final
};
|
15. explicit
禁止单参数构造函数的 “隐式转换”（避免意外类型转换）。
1 2 3 4 5 6 7 8 | classPoint {
public:
explicitPoint(intx) : x(x) {}// 禁止隐式转换
private:
intx;
};
Point p1(10);// 正确：显式构造
// Point p2 = 10; // 错误：explicit 禁止 int→Point 的隐式转换
|
16. noexcept（C++11+）
声明函数 “不会抛出异常”，帮助编译器优化，避免异常传播。
1 2 3 4 5 6 | voidfunc() noexcept {// 声明不抛异常
// 若函数内抛出异常，会调用 std::terminate()
}
voidfunc2() noexcept(false) {// 声明可能抛异常
throwstd::runtime_error("error");
}
|
17. constexpr（C++11+）
声明 “编译期常量” 或 “编译期可执行函数”（提升性能）。
1 2 3 | constexprintMAX = 100;// 编译期常量
constexprintadd(intx,inty) {returnx + y; }
constexprintsum = add(3, 5);// 编译期计算，sum=8
|
问题：const和constexpr的区别？
const表示运行时常量（值可能运行时确定）constexpr表示编译时常量（值必须编译时确定）constexpr函数可在编译期执行
