// report_export.cpp
std::string toCsvField(std::string_view s);          // 含 , " \n 时加引号，" 写两遍

// data_import.cpp（另一个团队写的）
std::vector<std::string> splitCsvLine(std::string_view line);
// 以引号开头的字段读到单独的引号为止；不支持字段内换行

// 调用方必须自己保证：先按行切，再调用 splitCsvLine
for (auto& line : splitLines(text)) rows.push_back(splitCsvLine(line));

"什么字符要加引号、引号如何转义、字段里能否换行"是同一份知识，却分在两个文件里，而且已经不一致：导出会给带换行的字段加引号，导入却按行切分，一读就错。调用方还要知道"先按行切"这条规则。

// csv.h —— 引号、转义、换行规则只在 csv.cpp 里定义一次
class CsvWriter {
public:
    explicit CsvWriter(std::ostream& out, char sep = ',');
    void writeRow(std::span<const std::string_view> fields);
};
class CsvReader {
public:
    explicit CsvReader(std::istream& in, char sep = ',');
    // 读下一条记录；字段内可以有换行。到达末尾返回 false。
    bool readRow(std::vector<std::string>& fields);
};

读和写放在同一个模块里，规则只定义一次，两边不会再走样。接口也更简单了：调用方不用再自己按行切，"一条记录可能跨行"这件事被藏了起来。代价是两个团队要共用一个模块，修改要更小心。

int copyFile(const char *src, const char *dst) {
    int in = open(src, O_RDONLY);
    if (in < 0) return -1;
    int out = open(dst, O_WRONLY | O_CREAT | O_TRUNC, 0644);
    if (out < 0) { close(in); return -1; }
    char *buf = malloc(BUFSZ);
    if (!buf) { close(out); close(in); return -1; }
    for (;;) {
        ssize_t n = read(in, buf, BUFSZ);
        if (n < 0) { free(buf); close(out); close(in); return -1; }
        if (n == 0) break;
        if (writeAll(out, buf, n) < 0) { free(buf); close(out); close(in); return -1; }
    }
    free(buf); close(out); close(in);
    return 0;
}

每多一种资源，之前的每个出错分支都要补一句释放；漏一处就是泄漏。

int copyFile(const char *src, const char *dst) {
    int rc = -1, in = -1, out = -1;
    char *buf = NULL;
    if ((in = open(src, O_RDONLY)) < 0) goto done;
    if ((out = open(dst, O_WRONLY | O_CREAT | O_TRUNC, 0644)) < 0) goto done;
    if (!(buf = malloc(BUFSZ))) goto done;
    for (;;) {
        ssize_t n = read(in, buf, BUFSZ);
        if (n < 0) goto done;
        if (n == 0) break;
        if (writeAll(out, buf, n) < 0) goto done;
    }
    rc = 0;
done:
    free(buf);
    if (out >= 0) close(out);
    if (in >= 0) close(in);
    return rc;
}

清理只写一次。作者承认 goto 名声不好、滥用会让代码没法读，但用来跳出嵌套代码、汇合到统一的清理正合适。（本站补充：Linux 内核里大量使用这种写法。）

// UniqueFd：析构时 close；openOrThrow 失败时抛 std::system_error
void copyFile(const std::string& src, const std::string& dst) {
    UniqueFd in  = openOrThrow(src, O_RDONLY);
    UniqueFd out = openOrThrow(dst, O_WRONLY | O_CREAT | O_TRUNC, 0644);
    std::vector<char> buf(kBufSize);
    while (size_t n = readOrThrow(in, buf)) writeAllOrThrow(out, {buf.data(), n});
}

本站补充：在 C++ 里，"清理只在一处执行"由析构函数在语言层面保证，连出口标签都不需要了。思路和 goto done 相同：把重复的代码变成只执行一次的代码。

const std::string* TtlCache::get(std::string_view key) {
    auto it = map_.find(key);
    if (it == map_.end() || it->second.expiresAt < clock_.now())
        return nullptr;
    // 登录会话每次访问续期 30 分钟，管理员会话不续期
    if (key.starts_with("sess:") && !looksLikeAdmin(it->second.value))
        it->second.expiresAt = clock_.now() + 30min;
    return &it->second.value;
}

十几个服务共用的缓存里，混进了只属于登录会话的规则：键前缀、角色判断、续期时长。会话规则每改一次，都得改这个公共模块。

// ttl_cache.h —— 只提供通用机制
class TtlCache {
public:
    const std::string* get(std::string_view key);
    void put(std::string key, std::string value, Duration ttl);
    bool extend(std::string_view key, Duration ttl);   // 给已有条目续期
};

// session_store.cpp —— 会话的规则都在这里
std::optional<Session> SessionStore::lookup(std::string_view id) {
    const std::string* raw = cache_.get(sessionKey(id));
    if (!raw) return std::nullopt;
    Session s = Session::decode(*raw);
    if (!s.isAdmin) cache_.extend(sessionKey(id), kIdleTimeout);
    return s;
}

缓存只多了一个通用的 extend，别的用途（比如滑动过期的限流记录）也能用；"谁续期、续多久"留在会话模块。改会话规则不再碰缓存。