class SegmentReader {            // 第一步：读
public:
    explicit SegmentReader(const std::string& dir);   // 按文件名顺序打开 seg-*.log
    std::optional<LogRecord> next();
};
class Redactor {                 // 第二步：改
public:
    void apply(LogRecord& r) const;
};
class SegmentWriter {            // 第三步：写
public:
    SegmentWriter(const std::string& dir, const char* namePattern, size_t rotateBytes);
    void append(const LogRecord& r);   // 实现：writeLE32(len); writeLE32(crc32(payload)); ...
};

// segment_reader.cpp
std::optional<LogRecord> SegmentReader::next() {
    uint32_t len = readLE32(in_);
    uint32_t crc = readLE32(in_);
    std::string payload = readBytes(in_, len);
    if (crc32(payload) != crc) throw CorruptSegment(path_);
    return decodeRecord(payload);    // 和 writer 里的 encodeRecord 必须严格互逆
}
// tools/fsck.cpp 里还有第三份：同样的 readLE32、同样的 crc32 比较……

第 13 行（写）、第 18～21 行（读）以及 fsck 里的第三份，各自"知道"帧格式和校验算法，但三个类的接口里都没有提到它们，这是后门泄漏。第 12 行更直接：文件命名模式和轮转阈值写进了构造函数签名，调用者被迫知道段文件怎么命名，这是接口泄漏。

// 一个目录下按顺序排列的一组段文件。帧格式、校验算法、记录编码、
// 文件命名与轮转规则，只在这个类的实现里出现。
class SegmentStore {
public:
    struct Options { size_t segmentBytes = 64 << 20; };  // 不同部署可能要调
    explicit SegmentStore(std::string dir, Options opt = {});

    class Scanner { public: std::optional<LogRecord> next(); /* … */ };
    Scanner scan() const;            // 按写入顺序遍历；损坏时抛 CorruptSegment（带文件名和偏移）
    void append(const LogRecord& r); // 满了自动换新段
    VerifyReport verify() const;     // 给 fsck 用
};

// main：顺序仍然在这里，但只剩顺序
SegmentStore in(srcDir), out(dstDir);
Redactor redact(rules);
for (auto it = in.scan(); auto rec = it.next(); ) {
    redact.apply(*rec);
    out.append(*rec);
}

读和写发生在不同的时刻，但它们依赖同一份知识，所以放进同一个类。fsck 工具变成一行 store.verify()。Redactor 仍然是单独的"一个阶段"，这没问题，因为脱敏规则和段文件格式毫无关系。

class RouteTable {
public:
    // 按前缀长度从长到短排好序；调用者可以从头扫描，第一个匹配的就是最长前缀
    const std::vector<Route>& routes() const { return routes_; }
    void setRoutes(std::vector<Route> r) { routes_ = std::move(r); }  // 调用者负责先排好序
private:
    std::vector<Route> routes_;
};

routes_ 是私有的，但"它是一个按前缀长度排序的 vector"这件事，以及"最长前缀匹配怎么做"，全都写在了接口注释里，每个调用者都依赖它。哪天为了性能换成前缀树（trie），所有调用者都得改。

class RouteTable {
public:
    // 最长前缀匹配；没有匹配的路由时返回 nullptr。
    const Route* lookup(IpAddr dst) const;
    void add(const Route& r);          // 前缀已存在时替换
    bool remove(const Prefix& p);      // 不存在时返回 false
private:
    std::vector<Route> routes_;        // 现在：排序数组；以后：随便换
};

表示方式和匹配算法都缩回了类里。顺带，lookup 让调用者少写一个循环，接口更深了。书中 5.6 节 HTTP 请求的 getParams() 返回内部 Map 是同一个问题，作者还指出了另一层风险：调用者可能改动返回的 Map，从而破坏对象的内部状态。