如何避免未向std::ofstream写入数据时创建空文件？

在C++中，创建std::ofstream时会立即生成底层文件，但如果代码需要在运行时才确定是否产生输出数据，我们希望无数据则不生成空文件，以此保证类似事务的完整性——没有输出就不修改文件系统。

目前有两种不太理想的解决思路：

• 方案1：通过tellg()检查流是否有数据写入，若为空则删除文件。但频繁创建删除文件会带来性能负担，且remove操作存在误删风险。
• 方案2：用std::stringstream暂存输出内容，仅当该流非空时再创建std::ofstream并复制内容。此方法比方案1更稳妥，但可能占用大量临时内存，不适合大输出量场景。

下面是几种更优的解决方案：

1. 延迟初始化std::ofstream #

将std::ofstream的创建延迟到第一次实际写入数据时，完全避免提前创建空文件。可以用智能指针实现这种延迟逻辑：

#include <fstream>
#include <memory>

int main()
{
    std::unique_ptr<std::ofstream> ofs_ptr;
    const char* filename = "file.txt";

    // 模拟可能触发输出的业务逻辑
    if (need_to_output()) {
        ofs_ptr = std::make_unique<std::ofstream>(filename);
        *ofs_ptr << "首次输出内容";
    }

    // 其他可能的输出操作
    if (another_output_condition()) {
        if (!ofs_ptr) {
            ofs_ptr = std::make_unique<std::ofstream>(filename);
        }
        *ofs_ptr << "追加输出内容";
    }

    // 智能指针会自动管理文件生命周期，从未创建则不会生成文件
}

这种方式无需额外内存缓存，也没有文件创建删除的额外开销，是最直接的解决方案。

2. 自定义懒加载流缓冲类 #

实现一个自定义的streambuf，先将少量数据缓存到内存，只有当缓存有数据或达到阈值时才打开文件写入。既避免了提前创建文件，又不会像std::stringstream那样占用过多内存：

#include <fstream>
#include <streambuf>
#include <vector>

class LazyFileBuf : public std::streambuf {
private:
    std::string filename_;
    std::vector<char> buffer_;
    std::ofstream ofs_;
    static constexpr size_t buffer_capacity = 1024; // 可根据需求调整

protected:
    int overflow(int c) override {
        // 第一次有数据时打开文件并写入缓存内容
        if (!ofs_.is_open() && !buffer_.empty()) {
            ofs_.open(filename_);
            if (!ofs_) return EOF;
            ofs_.write(buffer_.data(), buffer_.size());
            buffer_.clear();
        }

        if (ofs_.is_open()) {
            return ofs_.sputc(static_cast<char>(c));
        } else {
            // 缓存未满时先存内存，满了再打开文件
            if (buffer_.size() < buffer_capacity) {
                buffer_.push_back(static_cast<char>(c));
                return c;
            } else {
                ofs_.open(filename_);
                if (!ofs_) return EOF;
                ofs_.write(buffer_.data(), buffer_.size());
                buffer_.clear();
                return ofs_.sputc(static_cast<char>(c));
            }
        }
    }

    int sync() override {
        // 同步时确保缓存内容写入文件
        if (!ofs_.is_open() && !buffer_.empty()) {
            ofs_.open(filename_);
            if (!ofs_) return -1;
            ofs_.write(buffer_.data(), buffer_.size());
            buffer_.clear();
        }
        return ofs_.is_open() ? ofs_.sync() : 0;
    }

public:
    explicit LazyFileBuf(std::string filename) : filename_(std::move(filename)) {
        buffer_.reserve(buffer_capacity);
    }

    ~LazyFileBuf() {
        sync(); // 销毁时确保剩余缓存写入
    }
};

int main() {
    LazyFileBuf buf("file.txt");
    std::ostream os(&buf);

    // 可能会或不会输出的代码
    if (some_condition) {
        os << "需要输出的内容";
    }

    // 无任何输出时，buf不会打开文件，也就不会生成空文件
}

3. 临时文件原子替换 #

如果业务场景需要提前占用文件资源（比如防止其他进程修改目标文件），可以先创建临时文件，只有当有数据写入后，再原子性地将临时文件重命名为目标文件；无数据则删除临时文件：

#include <fstream>
#include <filesystem>

namespace fs = std::filesystem;

int main() {
    const char* target_file = "file.txt";
    std::string temp_file = std::string(target_file) + ".tmp";

    std::ofstream temp_ofs(temp_file);
    bool has_output = false;

    // 模拟输出逻辑
    if (should_output()) {
        temp_ofs << "完整输出内容";
        has_output = true;
    }

    temp_ofs.close();

    if (has_output) {
        fs::rename(temp_file, target_file); // 原子重命名，保证文件完整性
    } else {
        fs::remove(temp_file);
    }
}

这种方式能保证文件系统的原子性，避免出现损坏的半写入文件，适合对文件完整性要求高的场景。

内容的提问来源于stack exchange，提问作者Damir Tenishev