Skip to content

C++ 基础语法 ​


一、数据类型与类型转换 ​

1. 数据类型总览 ​

类型分类关键字常见字节数备注
整型int4最常用整数
short2短整型
long4 or 832位下4字节,64位Linux下8字节
long long8C++11 标准
字符型char1本质是整数(ASCII),分 signed/unsigned
浮点型float4约 7 位有效数字
double8约 15 位有效数字(默认推荐)
long double12 or 16高精度
布尔型bool1true(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 对象,而是为了:

  1. 调用没有 const 版本的旧接口
  2. 实现 const / 非 const 成员函数复用
  3. 处理底层 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_castdynamic_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.14const 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)=4

3. 二级指针 ​

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 后未置空,或返回局部变量地址)
值随机垃圾值曾经有效的地址(现已无效)

防御手段:

  1. 定义即初始化:int* p = nullptr;
  2. 释放即置空:delete p; p = nullptr;
  3. 不返回局部变量的地址/引用
  4. 优先使用智能指针: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**> 的含义:

这是理解这段代码的关键。拆成三步:

  1. ptr 是 void*,值是某空闲块的起始地址(如 0x1000)
  2. reinterpret_cast<void**>(ptr) 告诉编译器:"把 0x1000 当作指向指针的指针来看"
  3. 最外层 * 解引用:读取/写入 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 的区别?

sizeofstrlen
本质运算符(编译时求值)函数(运行时遍历)
计算对象任意类型或变量仅 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 / deletemalloc / 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: 什么是引用?它和指针有什么区别?(必问)

引用 = 给已有变量起别名。底层通常用指针常量实现。

引用的特性:

  1. 必须初始化:不能有空引用
  2. 不可重绑定:一旦绑定,终身绑定该变量
  3. 没有多级引用
特性引用 (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++ 编译器将函数签名(函数名 + 参数类型列表)编码为唯一的符号名。

语言编译后的符号说明
Cfunc → _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=6

3. 使用规范 ​

  • 定义在头文件:编译器必须看到函数体才能展开。
  • 短小精悍:超过 5~10 行编译器可能拒绝内联。
  • inline 只是建议,编译器有权忽略(如函数含循环/递归)。
  • 类内直接定义的成员函数自动隐含 inline。
  • inline 解决了 ODR 问题:同名 inline 函数在多个编译单元中定义不冲突,链接器保留一个副本。

十一、结构体 / 联合体 / 枚举 / 内存对齐 ​

1. struct vs class ​

Q: C++ 中 struct 和 class 的区别?(高频)

structclass
默认成员权限publicprivate
默认继承权限public 继承private 继承
其他完全相同(都可以有成员函数、构造/析构、继承、多态)

C++ 中 struct 不只是 C 时代的"数据集合",几乎就是 class。一般约定:纯数据聚合用 struct,有复杂逻辑用 class。

2. 内存对齐 ​

Q: 什么是内存对齐?为什么需要对齐?(高频)

对齐 = 数据成员的起始地址必须是其大小的整数倍。

为什么需要? CPU 按"块"(word,通常 4/8 字节)读取内存。如果数据跨越两个块,CPU 要读两次再拼接 → 效率极低。对齐保证一次读取。

对齐规则:

  1. 每个成员相对于结构体起始位置的偏移量必须是 min(成员大小, 对齐系数) 的整数倍
  2. 结构体总大小必须是其最大成员大小的整数倍(以便数组成员也对齐)
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)) = 4

4. 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;                      // ❌ 不会隐式转换
传统 enumenum 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;
#endif

2. 预定义宏 ​

宏含义
__LINE__当前行号
__FILE__当前源文件名
__FUNCTION__当前函数名
__DATE__编译日期
__TIME__编译时间

3. 为什么要少用宏? ​

  1. 无类型检查:错误只显示替换后的文本,不显示宏名 → 难调试
  2. 副作用陷阱(见上一节 SQUARE 例子)
  3. 作用域污染:全局有效,无法用 namespace 管理
  4. 调试器不可见:宏在预处理阶段就消失了

Effective C++ 条款 2:尽量以 const、enum、inline 替换 #define。


十三、编译链接 ​

1. 编译四个阶段 ​

Q: C++ 从源码到可执行文件经历了哪些阶段?(高频)

阶段核心任务输入 → 输出GCC 命令
预处理宏展开、#include、去注释.cpp → .ig++ -E
编译词法/语法/语义分析,生成汇编.i → .sg++ -S
汇编汇编→机器码,生成目标文件.s → .o / .objg++ -c
链接符号解析、地址重定位、库合并.o → .exe / a.outg++

常见报错定位:

报错示例阶段原因
No such file or directory预处理#include 路径错误
expected ';' / was not declared编译语法/拼写错误
undefined reference to 'xxx'链接声明了但没定义,或漏了库文件

2. extern "C" ​

Q: extern "C" 的作用是什么?为什么需要它?

作用:告诉 C++ 编译器,按 C 语言的规则编译和链接被修饰的代码——关掉名字修饰。

使用场景:

  1. C++ 调用 C 库
  2. 提供 C 可调用的 C++ 接口
cpp
// 标准写法(头文件中)
#ifdef __cplusplus
extern "C" {
#endif

void my_function(int a);   // 编译后符号名 = _my_function(而非 _Z12my_functioni)

#ifdef __cplusplus
}
#endif

Q: 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?

NULLnullptr (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结果
18 (0b00001000)8 & …111110008
815 (0b00001111)15 & …111110008
916 (0b00010000)16 & …1111100016
1320 (0b00010100)20 & …1111100016

核心原理: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 有效时不去 fetch

4. 逗号运算符 ​

从左到右依次求值,整个表达式的值 = 最后一个表达式的值。优先级最低。

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 12x86、ARM(默认)
cpp
// 判断当前机器的字节序
bool isLittleEndian() {
    int n = 1;
    // 如果低地址存的是 1(0x01),说明是小端
    return *(char*)&n == 1;
}

十七、内存重叠 ​

Q: memcpy 和 memmove 的区别?什么情况下用 memmove?

memcpymemmove
内存重叠不处理(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;
}