主题
C++ 基础语法
一、数据类型与类型转换
1. 数据类型总览
| 类型分类 | 关键字 | 常见字节数 | 备注 |
|---|---|---|---|
| 整型 | int | 4 | 最常用整数 |
short | 2 | 短整型 | |
long | 4 or 8 | 32位下4字节,64位Linux下8字节 | |
long long | 8 | C++11 标准 | |
| 字符型 | char | 1 | 本质是整数(ASCII),分 signed/unsigned |
| 浮点型 | float | 4 | 约 7 位有效数字 |
double | 8 | 约 15 位有效数字(默认推荐) | |
long double | 12 or 16 | 高精度 | |
| 布尔型 | bool | 1 | true(1) 或 false(0) |
| 无值型 | void | — | 用于函数返回值或无类型指针 |
- signed:有符号(默认),可表示正负数。
- unsigned:无符号,仅表示非负数(正数范围扩大一倍)。
auto:编译器根据初始值自动推导类型(C++11)。
2. 四种类型转换 (Type Cast)
Q: C++ 中四种强制类型转换分别是什么?各自的使用场景?
| 转换方式 | 用途 | 特点 |
|---|---|---|
static_cast | 相关类型间的安全转换(如 int→double,基类→派生类指针) | 编译时检查,不检查运行时的多态类型 |
const_cast | 移除/添加变量的 const 属性 | 唯一能去掉 const 的 cast;修改原 const 变量是未定义行为 |
dynamic_cast | 多态类型间的安全向下转换(基类指针→派生类指针) | 运行时检查,失败返回 nullptr(指针)或抛 std::bad_cast(引用);要求基类有虚函数 |
reinterpret_cast | 无关类型间的低级重解释(如 int*→char*) | 最危险,不改变二进制位,仅重新解释内存内容;平台相关 |
Q:
const_cast既然可以移除const属性,但是移除后依旧不能修改,那移除的意义是什么?
const_cast移除的是“编译器看到的 const”,不是对象本身的 const 属性。实际上
const_cast的主要用途不是为了修改 const 对象,而是为了:
- 调用没有 const 版本的旧接口
- 实现 const / 非 const 成员函数复用
- 处理底层 API 兼容问题
调用的时候需要保证代码里不能修改它的值,不然依旧Undefined Behavior(未定义行为)
具体的使用方法:
cpp
// static_cast
double d = 9.5;
int i = static_cast<int>(d); // i = 9
// const_cast — 风险操作,需谨慎
const int a = 10;
// &a 的类型是 const int*
int* p = const_cast<int*>(&a); // 允许编译通过,但修改 *p 是 UB
// dynamic_cast(Any类型转换见过)
Base* b = new Derived();
Derived* d = dynamic_cast<Derived*>(b); // 安全,运行时检查
// reinterpret_cast(内存池见过)
void* n = 0x12345678;
char* c = reinterpret_cast<char*>(&n);dynamic_cast 实战场景:类型擦除后的类型还原(线程池项目)
在线程池的 Any 类中,用"基类指针 + 模板派生类"实现类型擦除——存入任意类型,取出时用 dynamic_cast 安全还原:
cpp
// 类型擦除:Any 内部用 Base* 指向 Derive<T>
class Any {
struct Base { virtual ~Base() {} };
template<typename T>
struct Derive : Base { T data_; };
std::unique_ptr<Base> base_; // 擦除类型,统一存储
public:
template<typename T>
T cast_() {
// dynamic_cast 下行转换 + 运行时类型检查
Derive<T>* pd = dynamic_cast<Derive<T>*>(base_.get());
if (pd == nullptr) throw "type mismatch!";
return pd->data_;
}
};
Any a = 42; // 存入 int
int v = a.cast_<int>(); // 安全取出
// a.cast_<string>(); // ❌ 类型不匹配,dynamic_cast 返回 nullptr,抛出异常为什么这里必须用
dynamic_cast而非static_cast?Any内部擦除了类型信息,base_指向的可能是Derive<int>、Derive<string>等任意版本。static_cast不做运行时检查,一旦写错类型就是野指针访问;dynamic_cast发现类型不匹配会返回nullptr,给了程序安全兜底的机会。
区别:
| 特性 | static_cast | dynamic_cast |
|---|---|---|
| 转换时机 | 编译时 (Compile-time) | 运行时 (Runtime) |
| 安全性 | 不安全。不进行运行时的类型检查。 | 安全。会检查指针实际指向的对象是否匹配。 |
| 失败后果 | 返回错误类型的指针,调用时产生未定义行为。 | 如果不匹配,返回 nullptr(指针)或抛出异常(引用)。 |
| 类要求 | 无特殊要求(只要有继承关系即可)。 | 必须有虚函数(即类必须是多态的)。 |
| 性能 | 高。无运行时开销,仅做指针偏移计算。 | 低。需要查虚函数表和 RTTI(运行时类型信息)。 |
Q: C 风格强制转换
(type)expr有什么问题?C 风格转换 = 把
static_cast、const_cast、reinterpret_cast全试一遍,意图不明确、难以 grep 定位、可能无意间去掉 const。C++ 推荐用命名 cast 明确意图。
二、const
1. const 的四种用法
Q: const 在 C++ 中有哪些用途?
| 用法 | 示例 | 含义 |
|---|---|---|
| 修饰变量 | const int a = 10; | 变量初始化后不可修改 |
| 修饰指针 | 见下方「指针常量 vs 常量指针」 | 限制指针本身或指向内容的修改 |
| 修饰函数参数 | void f(const string& s) | 函数内不能修改该参数 |
| 修饰成员函数 | int get() const; | 该函数不能修改任何成员变量(mutable 除外) |
2. 常量指针 vs 指针常量
Q: 如何区分「常量指针」和「指针常量」?
核心记忆法:看 const 修饰的是谁。
cpp
const int* p; // 常量指针:const 修饰 *p(指向的内容),内容不能变
int* const p; // 指针常量:const 修饰 p(指针本身),指向不能变
const int* const p; // 两者结合:都不能变const int* p(常量指针) | int* const p(指针常量) | |
|---|---|---|
| 不能改的是什么 | *p(指向的内容) | p(指针本身的指向) |
| 可以改的是什么 | p 可以指向别处 | *p 可以修改内容 |
| 另一种写法 | int const* p(等价) | — |
3. 常引用绑定右值
常引用是指用 const 修饰的引用。通常情况下,右值(临时对象)在表达式结束后就会被销毁。但如果一个右值被绑定到一个常左值引用上,这个右值的生命周期会被延长到和这个引用一样长。而非常量左值引用是不可以的,因为引用的对象有可能被修改,而C++ 认定“修改一个即刻销毁的临时对象”在绝大多数情况下是程序 Bug,因此在编译阶段直接禁止。
cpp
// int& ref = 10; // 错误!普通引用不能绑定字面量
const int& ref = 10; // 正确!编译器创建临时变量,常引用绑定到临时变量这解释了为什么拷贝构造函数的参数是
const T&——可以接收右值/临时对象。
4. const 与 #define 的区别
Q: 为什么 Effective C++ 建议用 const 代替 #define 定义常量?
#define PI 3.14 | const double PI = 3.14; | |
|---|---|---|
| 处理阶段 | 预处理(文本替换) | 编译阶段 |
| 类型检查 | 无 | 有 |
| 作用域 | 全局(除非 #undef) | 遵循 C++ 作用域规则 |
| 调试可见性 | 符号表中看不到 PI | 符号表中有,调试器可见 |
| 内存占用 | 每处替换消耗一份代码空间 | 通常只有一份 |
三、static
Q: C++ 中 static 关键字的作用有哪些?(高频)
| 出现位置 | 作用 | 关键点 |
|---|---|---|
| 函数内部(局部静态变量) | 生命周期 = 程序全程 | 只初始化一次;函数结束不销毁 |
| 文件作用域(全局静态) | 限制可见性 | 仅在当前 .cpp 文件内可见(内部链接) |
| 类中静态成员变量 | 属于类,所有对象共享 | 必须在类外定义;不占对象 sizeof |
| 类中静态成员函数 | 无 this 指针 | 只能访问静态成员变量,不能访问普通成员变量 |
cpp
// 1. 局部静态变量
void counter()
{
static int n = 0; // 只初始化一次
n++;
cout << n << " "; // 三次调用输出: 1 2 3
}
// 2. 全局静态 — fileA.cpp
static int internalVar = 42; // fileB.cpp 无法用 extern 访问
// 3. 类静态成员
class Player {
public:
static int count; // 声明
Player() { count++; }
};
int Player::count = 0; // 【必须】在类外定义(通常在 .cpp 文件)Q: 静态成员函数为什么不能访问普通成员变量?
静态成员函数没有 this 指针。它可以通过 类名::函数() 直接调用,此时可能没有任何对象存在,所以不知道该访问哪个对象的普通成员。
Q: 为什么静态成员变量必须在类外定义?哪个是例外?为什么加 inline 又可以在类内初始化了?
根本原因 —— 存储分配 + ODR(唯一定义规则),分两层理解:
类内只是声明,不分配存储。 类的定义(含静态成员声明)通常在头文件里,会被多个 .cpp 包含。类内 static int count; 只是告诉类型系统"存在这样一个成员",不生成符号、不分配内存——所以多个翻译单元各自"看到"声明,互不冲突。
真正分配存储的"定义"全程序只能有一份(ODR)。 静态成员属于整个类而非某个对象,sizeof(对象) 不包含它,必须在全局作用域(通常写在一个 .cpp 里)定义一次,链接器把这份唯一的存储和所有引用对上:
如果允许在类内定义,而类定义在头文件里被多个 .cpp 包含,每个翻译单元都会生成一份符号 → 链接时报 **"multiple definition"(重复定义)**错误。
例外一:static const int 整型常量(C++98 起)可以在类内直接初始化:
cpp
class Config {
static const int VERSION = 3; // ✅ 类内直接初始化
};可以的原因:编译器把它当作编译期常量,用到的地方直接"值替换",不真正分配存储——没有存储就不违反 ODR。
例外二:inline static 成员变量(C++17 起):
cpp
class Config {
inline static int count = 0; // ✅ C++17:类内初始化,且就是定义
};为什么加 inline 就行?C++17 把 inline 从"内联函数"扩展为 inline 变量,含义是"允许多个翻译单元各有一份相同定义,链接器合并为一份,不违反 ODR"——和 inline 函数解决 ODR 是同一个原理(头文件里的 inline 函数被多个 .cpp 包含也不报重复定义)。
所以 inline static 成员兼具两个优点:类内直接初始化(写法方便) + 全程序唯一存储(ODR 安全),取代了"类内声明 + 类外定义"的传统写法。
四、extern
Q: extern 的作用是什么?
| 用法 | 作用 |
|---|---|
extern int globalVar; | 声明(而非定义),告诉编译器该变量在其他文件定义 |
extern "C" { ... } | 按 C 语言规则编译/链接,禁用名字修饰(详见编译链接章节) |
cpp
// fileA.cpp
int globalVar = 100; // 定义
// fileB.cpp
extern int globalVar; // 声明:引用 fileA.cpp 中的变量Q: 为什么头文件中不能直接定义变量?
头文件被多个
.cpp包含后,每个.cpp都会有一份定义,链接时报 "重复定义" 错误。正确做法:
.h中extern int a;(声明)- 某一个
.cpp中int a = 10;(定义)
五、指针
1. 指针基础
Q: 什么是指针?& 和 * 分别干什么?
- 指针变量:存储另一个变量的内存地址。
&(取地址):获取变量的地址。*(解引用):通过地址访问该位置存储的值。
cpp
int a = 10;
int* p = &a; // p 存储 a 的地址
cout << p; // 地址值,如 0x7ffee...
cout << *p; // 10(解引用)2. 指针运算
指针 ±n 移动的是 n × sizeof(T) 个字节,而非 n 个字节。
cpp
int arr[] = {10, 20, 30};
int* p = arr; // p 指向 arr[0]
p++; // p 现在指向 arr[1],地址增加了 sizeof(int)=43. 二级指针
Q: 什么是二级指针?什么时候用?
二级指针 = 指向指针的指针,存储一级指针变量的地址。
cpp
int a = 100;
int* p = &a; // 一级指针:存 a 的地址
int** pp = &p; // 二级指针:存 p 的地址
// *pp → p 的内容(即 a 的地址)
// **pp → a 的值(100)应用场景:在函数内修改外部指针的指向。
cpp
// 方式一:二级指针
void alloc(int** pp) {
*pp = new int(100); // 修改外部的指针
}
int* ptr = nullptr;
alloc(&ptr); // 传入 ptr 的地址
// 方式二:指针引用(更推荐,语义更清晰)
void alloc(int*& p) {
p = new int(100); // p 就是外部 ptr 的别名
}
int* ptr = nullptr;
alloc(ptr);典型应用:二叉树插入节点——需要修改父节点的
left/right指针的指向。
4. void* 指针(通用指针)
Q: void* 是什么?有什么限制?
void* 是"万能指针",可以指向任意类型,但编译器不知道指向的数据类型。
| 能做的 | 不能做的 |
|---|---|
| 接收任意类型的地址 | 不能解引用(不知道读几个字节) |
作为通用内存操作接口(malloc、memcpy 的参数) | 不能自增/自减(不知道步长) |
| 比较、赋值 | 使用前必须强转为具体类型 |
cpp
int n = 10;
void* vp = &n;
// int x = *vp; // ❌ 编译错误
int x = *(int*)vp; // ✅ 先强转再解引用5. 野指针 vs 悬空指针
Q: 野指针和悬空指针的区别?如何避免?
| 野指针 (Wild Pointer) | 悬空指针 (Dangling Pointer) | |
|---|---|---|
| 成因 | 定义后从未初始化 | 指向的内存已被释放(delete/free 后未置空,或返回局部变量地址) |
| 值 | 随机垃圾值 | 曾经有效的地址(现已无效) |
防御手段:
- 定义即初始化:
int* p = nullptr; - 释放即置空:
delete p; p = nullptr; - 不返回局部变量的地址/引用
- 优先使用智能指针:
std::unique_ptr/std::shared_ptr自动管理生命周期
6. 指针实战:嵌入式指针(内存池自由链表)
Q: 如何在不额外分配内存的情况下,用空闲内存块自身构建链表?
这是内存池/内存分配器中的核心技术。传统链表需要独立的节点结构体(含 next 指针),但内存池中的空闲块本身就是可被"征用"的内存——利用空闲块的前 8 字节存储 next 指针,零额外开销。
内存块处于"已分配"状态时:
[ 用户数据区 (size字节) ]
内存块处于"空闲"状态时:
[ next指针 (8字节) ][ 无用区域 (size-8字节) ]链表操作(假设 64 位系统,指针 8 字节):
cpp
// 从链表头取走一块(弹出操作)
void* head = freeList_[index]; // 保存链表头
freeList_[index] = *reinterpret_cast<void**>(head); // 链表头指向下一块
return head; // 返回取下的块
// 将一块归还链表(压入操作,头插法)
*reinterpret_cast<void**>(ptr) = freeList_[index]; // 归还块的 next = 旧链表头
freeList_[index] = ptr; // 链表头 = 归还块reinterpret_cast<void**> 的含义:
这是理解这段代码的关键。拆成三步:
ptr是void*,值是某空闲块的起始地址(如0x1000)reinterpret_cast<void**>(ptr)告诉编译器:"把 0x1000 当作指向指针的指针来看"- 最外层
*解引用:读取/写入 0x1000 处的前 8 字节,这 8 字节就是 next 指针
核心理解:同一个地址有两重身份——分配给用户时是"数据区起始地址",归还后是"next 指针的存储位置"。
reinterpret_cast就是切换这两种视角,不改变任何内存内容。
为什么最小粒度必须是 8 字节? 因为需要在空闲块中存储一个 void* 指针(64 位下 8 字节)。如果只分配 4 字节,归还时不够存 next 指针。
使用场景:
- TCMalloc / jemalloc 等工业级内存分配器的自由链表
- 线程池 中任务对象的内存管理
- 任何需要 O(1) 分配/释放且零额外开销的内存管理场景
六、数组与字符串
1. 数组基础
cpp
int arr[5] = {1, 2, 3, 4, 5};
int arr2[] = {10, 20}; // 自动推导长度 = 2| 特性 | 说明 |
|---|---|
| 下标从 0 开始 | arr[0] 是第一个元素 |
| 固定大小 | 编译时确定(std::vector 可动态扩容) |
| 不检查越界 | arr[10] 不会报错,读到垃圾值或崩溃(UB) |
| 数组名 ≈ 指针 | arr 可隐式退化为指向首元素的指针 |
2. 数组退化
Q: 什么是数组退化?如何避免?
数组作为函数参数传递时,会自动退化为指向首元素的指针,丢失长度信息。
cpp
void func(int a[]) {
cout << sizeof(a); // 输出 4 或 8(指针大小),不是数组总大小!
}
int arr[10];
cout << sizeof(arr); // 输出 40(10 × sizeof(int))
func(arr); // 退化发生避免退化:传数组引用、用模板推导、或用 std::array。
cpp
template<size_t N>
void func(int (&arr)[N]) { cout << N; } // 推导出长度
std::array<int, 10> arr; // 不会退化,自带 size()3. sizeof vs strlen
Q: sizeof 和 strlen 的区别?
sizeof | strlen | |
|---|---|---|
| 本质 | 运算符(编译时求值) | 函数(运行时遍历) |
| 计算对象 | 任意类型或变量 | 仅 C 风格字符串(char[]) |
是否含 \0 | 包含数组分配的全部字节 | 不包含结尾的 \0 |
| 适用场景 | 计算类型或数组字节数 | 计算字符串逻辑长度 |
cpp
char str[] = "Hello"; // 实际存储: H e l l o \0 — 6 字节
cout << sizeof(str); // 6(含 \0)
cout << strlen(str); // 5(不含 \0)注意:
sizeof大多数情况在编译期就能确定值(VLA 例外),不实际执行表达式。
4. std::string 与 C 字符串互转
cpp
// string → const char*
string s = "Hello";
const char* c = s.c_str();
// const char* → string
const char* c = "World";
string s = c;5. 读入带空格的字符串
cpp
string line;
getline(cin, line); // 读入一整行,遇换行停止
// cin >> str; // 遇到空格即停止七、动态内存管理
1. 内存四区
Q: C++ 程序运行时内存分为哪几个区域?
| 区域 | 存储内容 | 管理方式 | 生命周期 |
|---|---|---|---|
| 代码区 | 机器指令(只读) | OS 管理 | 程序运行全程 |
| 全局/静态区 | 全局变量、static 变量、常量 | 编译器分配/释放 | 程序运行全程 |
| 栈区 | 局部变量、函数参数、返回地址 | 编译器自动管理 | 离开作用域销毁 |
| 堆区 | 程序员动态分配的空间 | 程序员手动管理 | 手动释放或程序结束 |
栈 vs 堆:
| 栈 (Stack) | 堆 (Heap) | |
|---|---|---|
| 速度 | 极快(CPU 寄存器支持) | 较慢(需查找空闲块,易碎片) |
| 空间 | 较小(几 MB) | 很大(受虚拟内存限制) |
| 分配方式 | 连续,后进先出 | 任意顺序分配/释放 |
2. malloc/free vs new/delete
Q: new/delete 和 malloc/free 的区别?(高频)
new / delete | malloc / free | |
|---|---|---|
| 语言 | C++ 关键字**(对malloc/free的再封装)** | C 库函数 |
| 返回类型 | 具体类型指针(类型安全) | void*,需强转 |
| 大小计算 | 自动(编译器算) | 手动传字节数 |
| 构造/析构 | 会调用构造/析构函数**** | 不会(纯内存搬运) |
| 失败行为 | 默认抛 std::bad_alloc | 返回 NULL |
| 配套使用 | new ↔ delete,new[] ↔ delete[] | malloc ↔ free |
cpp
// C 风格
int* p = (int*)malloc(sizeof(int) * 5);
free(p);
p = nullptr; // 防止野指针
// C++ 风格
int* p = new int[5];
delete[] p; // new[] 必须搭配 delete[]!
p = nullptr;Q: 为什么 new[] 必须搭配 delete[]?
new[]会在数组首元素前额外分配空间记录数组元素个数,delete[]需要读取这个记录来知道要调用多少次析构函数。混用delete会导致只析构第一个元素,其余元素的内存泄漏 / 未析构。
3. nothrow new
cpp
int* p = new (std::nothrow) int[100];
if (p == nullptr) { /* 处理失败 */ }
// 默认 new 失败抛异常;nothrow 版本失败返回 nullptr八、引用
1. 引用的本质
Q: 什么是引用?它和指针有什么区别?(必问)
引用 = 给已有变量起别名。底层通常用指针常量实现。
引用的特性:
- 必须初始化:不能有空引用
- 不可重绑定:一旦绑定,终身绑定该变量
- 没有多级引用
| 特性 | 引用 (int& ref) | 指针 (int* ptr) |
|---|---|---|
| 初始化 | 必须在声明时绑定 | 可以先声明,后赋值 |
| 空值 | 不能为空 | 可以为 nullptr |
| 重定向 | 不可更改绑定对象(不能更改地址) | 可随时指向别处 |
| 解引用 | 自动(ref 就是原变量) | 需要 *ptr 显式解引用 |
| sizeof | 原变量大小 | 指针本身大小(4或8字节) |
| 多级 | 只有一级 | 有多级(int** 等) |
| 底层实现 | 通常是指针常量 T* const | 变量存储地址 |
2. 常引用
cpp
const int& ref = a; // 不能通过 ref 修改 a,但 a 本身可以改常引用可以绑定右值(临时对象):
cpp
const int& ref = 10; // ✅ 编译器创建临时变量,ref 绑定到它
// int& ref = 10; // ❌ 普通引用不能绑定字面量这也是函数参数写成
const T&的原因——既能接收左值,也能接收右值。
3. 引用作为返回值
cpp
int& bad() {
int a = 10;
return a; // ❌ 危险!返回局部变量的引用 → 悬空引用
}
int& good(int& x) {
return x; // ✅ 安全:返回传入的引用
}不能返回局部变量的引用/指针——函数返回后栈内存已释放,产生悬空引用。
九、函数
1. 参数传递三种方式
Q: 值传递、指针传递、引用传递的区别?
| 方式 | 语法 | 是否产生副本 | 能否修改实参 | 推荐场景 |
|---|---|---|---|---|
| 值传递 | void f(int a) | 是(拷贝) | 否 | 小型基本类型 |
| 指针传递 | void f(int* p) | 是(指针拷贝) | 是 | 可为空的参数、C 风格接口 |
| 引用传递 | void f(int& a) | 否(别名) | 是 | 大型对象、需修改的实参 |
| 常引用传递 | void f(const string& s) | 否(别名) | 否 | 最推荐的只读参数传递方式 |
cpp
void byValue(int a) { a = 10; } // 外部的 a 不变
void byPtr(int* a) { *a = 10; } // 外部被修改
void byRef(int& a) { a = 10; } // 外部被修改
void byCRef(const int& a) { /* a 只读 */ } // 高效 + 安全2. 函数重载
Q: C++ 如何支持函数重载?C 语言为什么不行?(高频)
重载:同一作用域内,函数名相同但参数列表不同(个数/类型/顺序)。返回类型不同不能作为重载依据。
原理 — 名字修饰 (Name Mangling):
C++ 编译器将函数签名(函数名 + 参数类型列表)编码为唯一的符号名。
| 语言 | 编译后的符号 | 说明 |
|---|---|---|
| C | func → _func | 只包含函数名,无法区分同名函数 |
| C++ (GCC) | func(int, char) → _Z4funcic | 编码了参数类型,同名不同参 → 不同符号 |
bash
nm my_program.o # Linux 下查看二进制中的符号表重载解析优先级:精确匹配 → 提升匹配(char→int) → 标准转换(int→double)。
3. 参数默认值
cpp
void log(string msg, int level = 1);
log("error"); // 等价于 log("error", 1);注意:默认参数必须从右向左连续设置(不能 int a=1, int b 这样跳着设)。
4. 函数指针
cpp
int add(int a, int b) { return a + b; }
// 定义函数指针:返回类型 (*指针名)(参数列表)
int (*p)(int, int) = add;
int result = p(10, 20); // 通过指针调用
// 作为回调参数
void execute(int a, int b, int (*op)(int, int)) {
cout << op(a, b);
}现代 C++ 更推荐
std::function+ Lambda 替代裸函数指针。
5. 递归
两要素:基准情形(停止条件)+ 递归步骤(缩小问题规模)。
风险:栈溢出(每层递归消耗栈帧)、重复计算(可用记忆化/动态规划优化)。
十、内联函数 (inline)
Q: 什么是内联函数?它和宏有什么区别?(高频)
内联函数的底层其实就是编译器在编译阶段把函数体直接‘拷贝’到了调用点。
1. 为什么需要内联?
函数调用有开销(压栈、跳转、返回)。对小函数(1~5 行),调用开销可能大于执行开销。内联将它们展开到调用处,消除调用开销,以空间换时间的思想。
inline 只是对编译器的一个“建议”,而不是“指令”
2. inline vs 宏
inline 函数 | #define 宏 | |
|---|---|---|
| 处理阶段 | 编译阶段 | 预处理阶段(文本替换) |
| 类型检查 | 有(真正的函数) | 无 |
| 副作用保护 | 有(参数只求值一次) | 无(参数可能求值多次) |
| 作用域 | 遵循 C++ 作用域规则 | 全局(除非 #undef) |
| 调试 | 调试模式下可单步进入 | 调试器中不可见 |
宏的经典陷阱 — 参数副作用:
cpp
#define SQUARE(x) ((x) * (x))
int a = 5;
int b = SQUARE(a++); // 展开为 ((a++)*(a++)) → UB!a 被改了两次
inline int square(int x) { return x * x; }
int b = square(a++); // 安全:先传值(5),a 再自增 → b=25, a=63. 使用规范
- 定义在头文件:编译器必须看到函数体才能展开。
- 短小精悍:超过 5~10 行编译器可能拒绝内联。
inline只是建议,编译器有权忽略(如函数含循环/递归)。- 类内直接定义的成员函数自动隐含 inline。
inline解决了 ODR 问题:同名 inline 函数在多个编译单元中定义不冲突,链接器保留一个副本。
十一、结构体 / 联合体 / 枚举 / 内存对齐
1. struct vs class
Q: C++ 中 struct 和 class 的区别?(高频)
struct | class | |
|---|---|---|
| 默认成员权限 | public | private |
| 默认继承权限 | public 继承 | private 继承 |
| 其他 | 完全相同(都可以有成员函数、构造/析构、继承、多态) |
C++ 中 struct 不只是 C 时代的"数据集合",几乎就是 class。一般约定:纯数据聚合用 struct,有复杂逻辑用 class。
2. 内存对齐
Q: 什么是内存对齐?为什么需要对齐?(高频)
对齐 = 数据成员的起始地址必须是其大小的整数倍。
为什么需要? CPU 按"块"(word,通常 4/8 字节)读取内存。如果数据跨越两个块,CPU 要读两次再拼接 → 效率极低。对齐保证一次读取。
对齐规则:
- 每个成员相对于结构体起始位置的偏移量必须是
min(成员大小, 对齐系数)的整数倍 - 结构体总大小必须是其最大成员大小的整数倍(以便数组成员也对齐)
cpp
struct Demo {
char a; // 1 字节,偏移 0
// 填充 3 字节
int b; // 4 字节,偏移 4
short c; // 2 字节,偏移 8
// 填充 2 字节(使总大小 = 最大成员 int 的倍数)
};
// sizeof(Demo) = 12,而非 1+4+2=7减小填充的技巧:按成员大小从大到小排列。
3. Union(联合体)
所有成员共享同一块内存,大小等于最大成员。同一时刻只能有效存储一个成员。
cpp
union Data {
int i;
float f;
char c;
};
// sizeof(Data) = max(sizeof(int), sizeof(float), sizeof(char)) = 44. Enum(枚举)
cpp
// 传统枚举
enum Color { RED, GREEN, BLUE }; // RED=0, GREEN=1, BLUE=2
// 强类型枚举 (C++11) — 推荐
enum class Color { Red, Green, Blue };
Color c = Color::Red; // 必须用作用域
// int n = c; // ❌ 不会隐式转换传统 enum | enum class (C++11) | |
|---|---|---|
| 作用域 | 污染外部作用域 | 需 枚举名::成员 访问 |
| 隐式转换 | 隐式→int | 不隐式转换,更安全 |
| 底层类型 | 实现定义 | 可指定(默认 int) |
十二、宏(预处理器)
Q: 宏有哪些常见用法?有什么缺陷?
1. 常见用法
cpp
// 常量宏
#define PI 3.14159
#define MAX_SIZE 1024
// 函数宏
#define MAX(a, b) ((a) > (b) ? (a) : (b))
// 条件编译 — 防止头文件重复包含
#ifndef MY_HEADER_H
#define MY_HEADER_H
// ... 头文件内容 ...
#endif
// 条件编译 — 调试开关
#ifdef DEBUG
cout << "调试信息" << endl;
#endif2. 预定义宏
| 宏 | 含义 |
|---|---|
__LINE__ | 当前行号 |
__FILE__ | 当前源文件名 |
__FUNCTION__ | 当前函数名 |
__DATE__ | 编译日期 |
__TIME__ | 编译时间 |
3. 为什么要少用宏?
- 无类型检查:错误只显示替换后的文本,不显示宏名 → 难调试
- 副作用陷阱(见上一节 SQUARE 例子)
- 作用域污染:全局有效,无法用 namespace 管理
- 调试器不可见:宏在预处理阶段就消失了
Effective C++ 条款 2:尽量以
const、enum、inline替换#define。
十三、编译链接
1. 编译四个阶段
Q: C++ 从源码到可执行文件经历了哪些阶段?(高频)
| 阶段 | 核心任务 | 输入 → 输出 | GCC 命令 |
|---|---|---|---|
| 预处理 | 宏展开、#include、去注释 | .cpp → .i | g++ -E |
| 编译 | 词法/语法/语义分析,生成汇编 | .i → .s | g++ -S |
| 汇编 | 汇编→机器码,生成目标文件 | .s → .o / .obj | g++ -c |
| 链接 | 符号解析、地址重定位、库合并 | .o → .exe / a.out | g++ |
常见报错定位:
| 报错示例 | 阶段 | 原因 |
|---|---|---|
No such file or directory | 预处理 | #include 路径错误 |
expected ';' / was not declared | 编译 | 语法/拼写错误 |
undefined reference to 'xxx' | 链接 | 声明了但没定义,或漏了库文件 |
2. extern "C"
Q: extern "C" 的作用是什么?为什么需要它?
作用:告诉 C++ 编译器,按 C 语言的规则编译和链接被修饰的代码——关掉名字修饰。
使用场景:
- C++ 调用 C 库
- 提供 C 可调用的 C++ 接口
cpp
// 标准写法(头文件中)
#ifdef __cplusplus
extern "C" {
#endif
void my_function(int a); // 编译后符号名 = _my_function(而非 _Z12my_functioni)
#ifdef __cplusplus
}
#endifQ: extern "C" 里的函数能重载吗? 不能。重载依赖名字修饰,
extern "C"禁用了名字修饰,同名函数会符号冲突。
十四、更多关键字
1. volatile
Q: volatile 的作用是什么?
告诉编译器:每次访问这个变量都必须从内存读取,禁止寄存器缓存或指令重排。
cpp
volatile int flag = 0;
// 适用场景:
// 1. 硬件寄存器映射
// 2. 信号处理函数中修改的变量
// 3. 多线程共享变量(注意:volatile ≠ 原子操作,多线程请用 std::atomic)常见误解:
volatile不能保证线程安全!它不保证原子性,也不保证内存序。多线程同步请用std::atomic或互斥锁。
2. typedef / using
cpp
// typedef — C 风格
typedef unsigned int uint32;
typedef int (*FuncPtr)(int, int); // 函数指针类型别名
// using — C++11 推荐
using uint32 = unsigned int; // 更直观
using FuncPtr = int(*)(int, int);
// using 独有的模板别名
template<typename T>
using Vec = std::vector<T>;3. constexpr (C++11,简要)
编译期常量:确保表达式在编译期就能计算出结果。比 const 更强——const 只保证不可修改,不保证编译期求值。
cpp
constexpr int square(int x) { return x * x; }
int arr[square(3)]; // ✅ 编译期确定数组大小4. explicit (C++,简要)
禁止隐式类型转换。主要用于单参数构造函数,防止意外的隐式构造。
cpp
class MyString {
public:
explicit MyString(int n); // 禁止 MyString s = 5; 这种隐式转换
};5. nullptr vs NULL
Q: nullptr 和 NULL 有什么区别?为什么推荐 nullptr?
NULL | nullptr (C++11) | |
|---|---|---|
| 本质 | 宏,通常定义为 0 或 (void*)0 | 关键字,类型为 std::nullptr_t |
| 类型 | 整型(可能引发重载歧义) | 明确的空指针类型 |
cpp
void f(int);
void f(int*);
f(NULL); // 可能调用 f(int),不符合预期!
f(nullptr); // 明确调用 f(int*)十五、运算符与表达式
1. 位运算
| 运算符 | 名称 | 规则 |
|---|---|---|
& | 按位与 | 同为 1 则为 1 |
| ` | ` | 按位或 |
^ | 按位异或 | 不同为 1,相同为 0 |
~ | 按位取反 | 0↔1 |
<< | 左移 | 右边补 0,左移 n 位 = 乘 $2^n$ |
>> | 右移 | 左边补符号位(算术右移) |
2. 位运算实战:向上对齐(内存池经典操作)
Q: 如何用位运算高效地将任意整数向上取整到 8 的倍数?
这是内存池/内存分配器中的经典操作——用户请求的字节数必须对齐到最小粒度(如 8 字节)。
cpp
// 一行代码实现向上对齐到 8 的倍数
inline size_t roundUp(size_t bytes) {
return (bytes + ALIGNMENT - 1) & ~(ALIGNMENT - 1); // ALIGNMENT = 8
}分步拆解(以 ALIGNMENT = 8 为例):
| 步骤 | 操作 | 作用 |
|---|---|---|
| 第一步 | bytes + 7 | 向上进位:如果 bytes 不是 8 的倍数,低位"溢出"到下一个 8 的边界 |
| 第二步 | & ~7 | 掩码清零低 3 位:~7 = ...11111000,按位与将低 3 位置 0 |
实例演算:
| 请求大小 | 第一步 bytes + 7 | 第二步 & ~7 | 结果 |
|---|---|---|---|
| 1 | 8 (0b00001000) | 8 & …11111000 | 8 |
| 8 | 15 (0b00001111) | 15 & …11111000 | 8 |
| 9 | 16 (0b00010000) | 16 & …11111000 | 16 |
| 13 | 20 (0b00010100) | 20 & …11111000 | 16 |
核心原理:8 的倍数二进制低 3 位必为 0。
bytes + 7保证进位到下一个边界,& ~7把低 3 位清零 → 得到 ≥ bytes 的最小 8 的倍数。
泛化公式:对齐到任意 2 的幂次 N:
cpp
inline size_t roundUp(size_t bytes, size_t alignment) {
return (bytes + alignment - 1) & ~(alignment - 1);
}
// 前提:alignment 必须是 2 的幂次(8, 16, 32, 64...)3. 逻辑短路
cpp
// &&:左侧 false → 右侧不执行
if (ptr != nullptr && *ptr > 10) // 安全:ptr 为空时不解引用
// ||:左侧 true → 右侧不执行
if (cache.isValid() || fetchData()) // cache 有效时不去 fetch4. 逗号运算符
从左到右依次求值,整个表达式的值 = 最后一个表达式的值。优先级最低。
cpp
int a = (1, 2, 3); // a = 3
for (int i = 0, j = 10; i < j; i++, j--) { ... }5. 三目运算符
cpp
int max = (a > b) ? a : b; // 条件为 true 取冒号左边,false 取右边注意:两个分支的返回类型必须兼容。
十六、大小端
Q: 什么是大端和小端?如何用代码判断?
| 定义 | 示例(0x12345678 在内存中) | 常见平台 | |
|---|---|---|---|
| 大端 | 高位字节存低地址 | 12 34 56 78 | 网络字节序 |
| 小端 | 低位字节存低地址 | 78 56 34 12 | x86、ARM(默认) |
cpp
// 判断当前机器的字节序
bool isLittleEndian() {
int n = 1;
// 如果低地址存的是 1(0x01),说明是小端
return *(char*)&n == 1;
}十七、内存重叠
Q: memcpy 和 memmove 的区别?什么情况下用 memmove?
memcpy | memmove | |
|---|---|---|
| 内存重叠 | 不处理(UB) | 安全处理 |
| 实现策略 | 始终正向拷贝 | 判断 src/dest 位置,必要时反向 |
| 性能 | 略快 | 略有判断开销 |
重叠场景:dest 和 src 地址范围有交集。如果 dest > src 且 dest < src + n,正向拷贝会覆盖还未读取的源数据 → 需要从后往前(反向)拷贝。
cpp
void* my_memmove(void* dest, const void* src, size_t n) {
char* d = (char*)dest;
const char* s = (const char*)src;
if (d > s && d < s + n) {
// 重叠且 dest 在 src 之后 → 反向拷贝
d += n - 1; s += n - 1;
while (n--) *d-- = *s--;
} else {
// 正向拷贝
while (n--) *d++ = *s++;
}
return dest;
}