C++实现控制台格式化输出与派生类专属日志文件同步记录方案咨询

刚好遇到过类似的需求，给你两种靠谱的解决方案：一种是基于C++标准库自己实现双输出流，完全贴合你想要的custom_out << ...调用方式；另一种是用成熟的日志库快速搞定，还能获得更多扩展功能。

方案一：基于C++标准库自定义双输出流 #

核心思路是继承std::streambuf，实现一个同时向控制台和文件输出的缓冲区——控制台输出自动添加类名前缀，文件输出直接写入原始内容。然后在基类中封装这个自定义缓冲区和对应的std::ostream对象，派生类只需要初始化时传入自己的类名和日志文件路径即可。

代码实现 #

#include <iostream>
#include <fstream>
#include <streambuf>
#include <string>
#include <algorithm>

// 自定义双输出流缓冲区：同时输出到控制台（带前缀）和文件（无前缀）
class DoubleOutputBuf : public std::streambuf {
public:
    DoubleOutputBuf(std::ostream& console, std::ofstream& file, const std::string& prefix)
        : console_buf_(console.rdbuf()), file_buf_(file.rdbuf()), prefix_(prefix), need_prefix_(true) {}

protected:
    // 处理单个字符输出
    int_type overflow(int_type c) override {
        if (need_prefix_) {
            // 控制台输出前缀
            console_buf_->sputn(prefix_.data(), prefix_.size());
            need_prefix_ = false;
        }
        // 同时输出到控制台和文件
        if (c != traits_type::eof()) {
            console_buf_->sputc(c);
            file_buf_->sputc(c);
        }
        // 换行后标记下一次需要输出前缀
        if (c == '\n') {
            need_prefix_ = true;
        }
        return c;
    }

    // 处理批量字符输出（比如std::string的输出）
    std::streamsize xsputn(const char* s, std::streamsize count) override {
        if (need_prefix_) {
            console_buf_->sputn(prefix_.data(), prefix_.size());
            need_prefix_ = false;
        }
        // 批量写入两个目标
        console_buf_->sputn(s, count);
        file_buf_->sputn(s, count);
        // 检查内容中是否包含换行，更新前缀标记
        const char* newline = std::find(s, s + count, '\n');
        if (newline != s + count) {
            need_prefix_ = true;
        }
        return count;
    }

private:
    std::streambuf* console_buf_;
    std::streambuf* file_buf_;
    std::string prefix_;
    bool need_prefix_; // 标记下一次输出是否需要添加前缀
};

// 基类：封装日志流
class ProcessingThread {
protected:
    std::ofstream log_file_;
    DoubleOutputBuf double_buf_;
    std::ostream custom_out_;

public:
    ProcessingThread(const std::string& class_name, const std::string& log_file_path)
        : log_file_(log_file_path),
          double_buf_(std::cout, log_file_, "[" + class_name + "]: "),
          custom_out_(&double_buf_) {
        // 确保文件打开成功，如果需要可以加错误处理
        if (!log_file_.is_open()) {
            std::cerr << "无法打开日志文件：" << log_file_path << std::endl;
        }
    }

    // 禁用拷贝构造和赋值，因为流对象不可拷贝
    ProcessingThread(const ProcessingThread&) = delete;
    ProcessingThread& operator=(const ProcessingThread&) = delete;

    virtual ~ProcessingThread() {
        if (log_file_.is_open()) {
            log_file_.close();
        }
    }
};

// 派生类示例
class DerivationOne : public ProcessingThread {
public:
    DerivationOne() : ProcessingThread("DerivationOne", "derivation_one.log") {}

    void doOperationX() {
        custom_out << "执行了操作X！" << std::endl;
    }
};

class DerivationTwo : public ProcessingThread {
public:
    DerivationTwo() : ProcessingThread("DerivationTwo", "derivation_two.log") {}

    void doOperationY() {
        custom_out << "执行了操作Y！" << std::endl;
    }

    void doOperationZ() {
        custom_out << "执行了操作Z！" << std::endl;
    }
};

关键说明 #

• 完全基于C++标准库，无需额外依赖，调用方式完全符合你的预期：custom_out << "内容" << std::endl;
• 自动处理前缀逻辑：每一行日志开头都会自动添加[类名]:前缀，换行后自动重置标记
• 注意流对象的生命周期：基类中已经处理了文件流的打开和关闭，派生类只需要传入参数即可

方案二：使用现成日志库（以spdlog为例） #

如果你的项目可以引入第三方库，spdlog是一个非常推荐的轻量级C++日志库，它支持多输出目标、线程安全、日志级别、颜色输出等功能，能快速实现你的需求，还能扩展更多日志能力。

代码实现 #

#include <spdlog/spdlog.h>
#include <spdlog/sinks/stdout_color_sinks.h>
#include <spdlog/sinks/basic_file_sink.h>

class ProcessingThread {
protected:
    std::shared_ptr<spdlog::logger> logger_;

public:
    ProcessingThread(const std::string& class_name, const std::string& log_file_path) {
        // 创建控制台输出sink，格式包含类名前缀
        auto console_sink = std::make_shared<spdlog::sinks::stdout_color_sink_mt>();
        console_sink->set_pattern("[%s]: %v"); // %s是logger名称（这里用类名），%v是日志内容

        // 创建文件输出sink，格式仅保留日志内容
        auto file_sink = std::make_shared<spdlog::sinks::basic_file_sink_mt>(log_file_path, true);
        file_sink->set_pattern("%v");

        // 组合两个sink到自定义logger
        logger_ = std::make_shared<spdlog::logger>(class_name, spdlog::sinks_init_list{console_sink, file_sink});
        spdlog::register_logger(logger_);
    }

    virtual ~ProcessingThread() = default;
};

// 派生类示例
class DerivationOne : public ProcessingThread {
public:
    DerivationOne() : ProcessingThread("DerivationOne", "derivation_one.log") {}

    void doOperationX() {
        logger_->info("执行了操作X！");
    }
};

class DerivationTwo : public ProcessingThread {
public:
    DerivationTwo() : ProcessingThread("DerivationTwo", "derivation_two.log") {}

    void doOperationY() {
        logger_->info("执行了操作Y！");
    }

    void doOperationZ() {
        logger_->info("执行了操作Z！");
    }
};

关键说明 #

• 调用方式是logger_->info(...)，虽然和你想要的流方式略有不同，但更简洁，还支持不同日志级别（info/warn/error等）
• 天然支持线程安全（因为你的类是ProcessingThread，大概率是多线程场景）
• 可以轻松扩展：比如添加日志文件滚动、按级别过滤、格式化更多信息（时间、线程ID等）

总结 #

• 如果不想引入第三方库，方案一完全满足你的需求，纯标准实现，调用方式贴合预期
• 如果需要更多日志功能（线程安全、级别管理、滚动日志等），方案二更高效，减少自己造轮子的成本

内容的提问来源于stack exchange，提问作者Alex Pander