阅读遗留代码

在现实工作中,你会遇到大量 C++98/03 时代的遗留代码。本章不是教你写这些旧代码,而是教你读懂它们——理解旧模式的含义,以及它们在现代 C++ 中的对应方案。当你在代码库中看到这些模式时,你就知道它在做什么。

为什么需要这一章?

本课程全程使用现代 C++ 教学。但真实世界的代码库中,遗留代码无处不在——开源项目、公司代码、Stack Overflow 上的旧回答。能读懂遗留代码是工程师的必备能力,即使你永远不会主动写这些代码。

裸指针 (Raw Pointers)

在旧代码中,裸指针承担了太多职责:所有权、观察、多态、可空引用……现代 C++ 将这些职责分离到不同的类型中。

// ===== 旧代码中的裸指针 =====
class OldEngine {
    Renderer* renderer_;    // 拥有?观察?不清楚!
    Logger* logger_;        // 谁负责 delete?
public:
    OldEngine(Renderer* r, Logger* l) : renderer_(r), logger_(l) {}
    ~OldEngine() {
        delete renderer_;   // 原来 renderer_ 是拥有的
        // logger_ 不 delete —— 原来是观察的
    }
};

// ===== 现代等价 =====
#include <memory>

class ModernEngine {
    std::unique_ptr<Renderer> renderer_;  // 明确拥有
    Logger* logger_;                       // 裸指针 = 非拥有观察者(现代惯例)
public:
    ModernEngine(std::unique_ptr<Renderer> r, Logger& l)
        : renderer_(std::move(r)), logger_(&l) {}
    // 无需手写析构函数!unique_ptr 自动释放
};

现代代码中裸指针的含义

在现代 C++ 中,裸指针表示非拥有的可空观察者。如果不需要"空"的可能性,使用引用 T&。如果需要所有权,使用 unique_ptr 或 shared_ptr。

new / delete

旧代码中充斥着手动内存管理。这是内存泄漏、double-free、use-after-free 等 bug 的主要来源:

// ===== 旧代码 =====
Widget* create_widget() {
    Widget* w = new Widget();   // 谁来 delete?调用者!
    w->init();
    return w;                    // 所有权转移了,但接口没有表达这一点
}

void old_usage() {
    Widget* w = create_widget();
    process(w);
    delete w;                    // 忘记 delete → 泄漏
                                 // 异常中途抛出 → 泄漏
                                 // delete 两次 → UB
}

// ===== 现代等价 =====
#include <memory>

std::unique_ptr<Widget> create_widget() {
    auto w = std::make_unique<Widget>();  // 所有权明确
    w->init();
    return w;   // 移动返回,零开销
}

void modern_usage() {
    auto w = create_widget();   // unique_ptr 自动管理生命周期
    process(*w);
    // 离开作用域自动 delete,异常安全
}

C 数组与指针算术

// ===== 旧代码 =====
void process_old(int* data, int size) {    // 数组退化为指针,丢失大小信息
    for (int i = 0; i < size; ++i) {
        *(data + i) *= 2;                   // 指针算术
    }
}

void caller_old() {
    int arr[100];
    process_old(arr, 100);     // 大小手动传递,容易出错
    process_old(arr, 200);     // 编译通过!但越界 → UB
}

// ===== 现代等价 =====
#include <span>
#include <array>
#include <vector>

void process_modern(std::span<int> data) {  // 携带大小信息,零拷贝
    for (auto& x : data) {
        x *= 2;                              // 范围 for,不可能越界
    }
}

void caller_modern() {
    std::array<int, 100> arr{};
    process_modern(arr);                     // 自动推导大小

    std::vector<int> vec(200);
    process_modern(vec);                     // 也适用于 vector
}

C 风格字符串

// ===== 旧代码 =====
#include <cstring>
#include <cstdlib>

void old_strings() {
    const char* greeting = "Hello";
    char buffer[256];

    strcpy(buffer, greeting);              // 不检查长度 → 缓冲区溢出风险
    strcat(buffer, " World");              // 同样危险
    int len = strlen(buffer);              // O(n) 每次都要遍历找 '\0'

    // 动态字符串
    char* name = (char*)malloc(64);
    strcpy(name, "Alice");
    // ... 忘记 free(name) → 泄漏
    free(name);
}

// ===== 现代等价 =====
#include <string>
#include <string_view>

void modern_strings() {
    std::string greeting = "Hello";
    greeting += " World";                  // 自动管理内存,安全拼接
    auto len = greeting.size();            // O(1)

    // 非拥有视图(零拷贝)
    std::string_view sv = greeting;        // 不分配内存
    auto sub = sv.substr(0, 5);            // 视图切片,O(1)
}

#include vs 模块

// ===== 旧代码:头文件模型 =====
// math_utils.h
#ifndef MATH_UTILS_H          // include guard(手动防重复包含)
#define MATH_UTILS_H

#include <vector>              // 传递性包含,污染所有包含者
#include <algorithm>

inline double average(const std::vector<double>& v) {
    // 实现必须放在头文件(或分离 .cpp 但不能内联)
    double sum = 0;
    for (auto x : v) sum += x;
    return sum / v.size();
}

#endif // MATH_UTILS_H

// ===== 现代等价:C++20 模块 =====
// math_utils.cppm
export module math_utils;       // 声明模块

import <vector>;                // 不会泄漏到导入者
import <numeric>;

export double average(const std::vector<double>& v) {
    return std::accumulate(v.begin(), v.end(), 0.0) / v.size();
}
// 导入者只看到 export 的内容,编译更快,无宏污染

宏 (Macros)

旧代码大量使用预处理宏实现"泛型"和"常量"。现代 C++ 有更好的替代:

// ===== 旧代码中宏的常见用途 =====

// 1. "常量"
#define MAX_SIZE 1024
#define PI 3.14159265358979

// 2. "泛型函数"
#define MAX(a, b) ((a) > (b) ? (a) : (b))    // 经典陷阱:MAX(i++, j++)

// 3. "类型安全的枚举"
#define COLOR_RED   0
#define COLOR_GREEN 1
#define COLOR_BLUE  2

// 4. 代码生成 / 重复消除
#define DECLARE_GETTER(Type, name) \
    Type get_##name() const { return name##_; }

// ===== 现代等价 =====

// 1. constexpr 常量(类型安全,有作用域)
constexpr int max_size = 1024;
constexpr double pi = 3.14159265358979;

// 2. 函数模板(类型安全,可调试)
template<typename T>
constexpr T max_of(T a, T b) { return a > b ? a : b; }

// 3. enum class(强类型,有作用域)
enum class Color { red, green, blue };

// 4. 反射(C++26)或 constexpr + 模板
// 在 C++26 之前,可用模板元编程替代部分代码生成

旧风格类型转换

// ===== 旧代码 =====
void old_casts() {
    double d = 3.14;
    int i = (int)d;                        // C 风格强转:什么都能转,不安全

    Base* base = get_object();
    Derived* derived = (Derived*)base;      // 没有运行时检查

    const Data* cd = get_data();
    Data* d2 = (Data*)cd;                   // 静默移除 const
}

// ===== 现代等价 =====
void modern_casts() {
    double d = 3.14;
    int i = static_cast<int>(d);           // 明确意图:数值转换

    Base* base = get_object();
    auto* derived = dynamic_cast<Derived*>(base);  // 安全向下转型
    if (derived) { /* 使用 derived */ }              // 失败返回 nullptr

    // const_cast —— 极少使用,表示"我知道我在做什么"
    // reinterpret_cast —— 底层位模式重解释,几乎不应使用
}

typedef vs using

// ===== 旧代码 =====
typedef unsigned long size_type;
typedef void (*callback_fn)(int, int);                   // 函数指针:难以阅读
typedef std::map<std::string, std::vector<int>> DataMap; // 嵌套模板

// ===== 现代等价 =====
using size_type = unsigned long;                          // 清晰的 "name = type" 格式
using callback_fn = void(*)(int, int);                    // 同样的函数指针,更易读
using DataMap = std::map<std::string, std::vector<int>>; // 一致的语法

// using 还支持模板别名(typedef 做不到!)
template<typename T>
using Vec = std::vector<T, MyAllocator<T>>;   // 模板别名

Vec<int> numbers;      // = std::vector<int, MyAllocator<int>>

遗留代码 → 现代 C++ 翻译表

遗留模式现代替代关键改进
T* p = new T(); auto p = std::make_unique<T>(); 自动释放,异常安全
delete p; (不需要——RAII 自动管理) 无泄漏、无 double-free
int arr[N]; std::array<int, N> 知道大小,可拷贝,STL 兼容
void f(int* p, int n) void f(std::span<int> s) 大小绑定,防止越界
char* / strlen / strcpy std::string / string_view 自动内存管理,O(1) size
#define CONST 42 constexpr int CONST = 42; 类型安全,有作用域
#define MAX(a,b) ... std::max(a, b) 或模板 无多次求值陷阱
enum { RED, GREEN } enum class Color { red, green } 强类型,不隐式转换
(int)x static_cast<int>(x) 明确意图,可搜索
typedef T alias; using alias = T; 统一语法,支持模板别名
#include + include guard import module; 编译快,无宏泄漏
NULL nullptr 类型安全(不会匹配 int 重载)
for (int i=0; i<v.size(); ++i) for (auto& x : v) 不可能越界,意图更清晰

阅读遗留代码的心法

  1. 不要恐慌:遗留代码看起来复杂,但底层逻辑通常很简单——只是表达方式更冗长
  2. 识别所有权:看到裸指针时,追踪"谁 new、谁 delete"来理解生命周期
  3. 忽略样板代码:include guard、手写析构、拷贝构造——这些在现代 C++ 中自动处理
  4. 关注业务逻辑:剥离资源管理噪音后,关注函数真正在做什么
  5. 用 IDE 辅助:使用"Go to Definition"追踪 typedef 和宏展开

渐进式现代化

面对遗留代码库,不要试图一次性重写。正确的策略是:新代码用现代风格编写,修改旧代码时顺手将接触的部分升级(如将 new/delete 替换为 unique_ptr)。务必在有测试覆盖的前提下进行改造。

本章小结

  • 遗留代码中的裸指针可能表示所有权或观察——现代代码用 unique_ptr 和引用区分
  • new/delete 已被 RAII 智能指针取代,消除了内存泄漏的可能
  • C 数组退化为指针会丢失大小信息,std::span 和 std::array 解决了这个问题
  • C 风格字符串(char*)的痛点被 std::string 和 string_view 彻底消除
  • 宏的各种用途(常量、泛型、枚举)都有更安全的现代替代方案
  • 掌握这张"翻译表"后,你就能流畅地阅读任何时代的 C++ 代码