Linux现有程序无需全量改源码，如何将std::cout绑定至日志函数？

嘿，这个需求我之前在多线程服务里实现过，完全不用动现有业务代码，给你两个最靠谱的方案，重点推荐第二个，完美匹配你的诉求：

方案一：替换std::cout的底层streambuf（适合简单输出拦截，但获取调用方信息有局限） #

std::cout本质是一个ostream对象，底层依赖streambuf来处理输出。我们可以自定义一个streambuf，把它替换成cout的默认缓冲区，从而拦截所有输出：

1. 自定义日志缓冲区类

#include <streambuf>
#include <string>
#include <mutex>

class LogStreambuf : public std::streambuf {
private:
    std::string buffer_;
    std::mutex mutex_; // 多线程安全锁

protected:
    // 处理单个字符输出
    int_type overflow(int_type c) override {
        if (c != traits_type::eof()) {
            buffer_ += static_cast<char>(c);
            // 遇到换行就触发日志输出
            if (c == '\n') {
                sync();
            }
        }
        return c;
    }

    // 同步缓冲区（触发日志发送）
    int sync() override {
        std::lock_guard<std::mutex> lock(mutex_);
        if (!buffer_.empty()) {
            // 这里调用你的日志函数，注意：这里无法直接获取调用方函数名
            your_log_function(buffer_.c_str());
            buffer_.clear();
        }
        return 0;
    }
};

2. 替换cout的缓冲区
   在程序启动时（比如main函数开头）执行：

#include <iostream>

LogStreambuf log_buf;
// 保存原来的缓冲区，方便后续恢复（可选）
std::streambuf* old_buf = std::cout.rdbuf(&log_buf);

⚠️ 注意：这个方案的短板是无法直接获取调用方函数名，因为streambuf的回调是在cout的operator<<内部触发的，__func__宏只能拿到operator<<的函数名，不是业务代码里调用cout的函数名。如果你的日志必须要调用方信息，这个方案就不太适用了。

方案二：宏替换+临时对象（完美获取调用方信息，无需修改业务代码） #

这个方案通过全局宏把cout替换成一个自定义的临时对象，在对象构造时捕获调用方函数名，析构时把收集的输出和函数名一起传给日志函数，完全不需要修改现有业务代码：

1. 定义日志包装类

#include <sstream>
#include <string>
#include <mutex>

// 全局锁保证日志函数线程安全
std::mutex log_mutex;

void your_log_function(const char* func_name, const char* msg) {
    std::lock_guard<std::mutex> lock(log_mutex);
    // 这里实现你的日志逻辑，比如打印到文件/系统日志等
    printf("[%s] %s\n", func_name, msg);
}

class LogWrapper {
private:
    std::ostringstream oss_;
    const char* func_name_;

public:
    // 构造时捕获调用方函数名
    explicit LogWrapper(const char* func_name) : func_name_(func_name) {}

    // 析构时触发日志发送（语句结束时自动调用）
    ~LogWrapper() {
        std::string msg = oss_.str();
        if (!msg.empty()) {
            // 去掉末尾的换行（如果有的话，避免重复换行）
            if (!msg.empty() && msg.back() == '\n') {
                msg.pop_back();
            }
            your_log_function(func_name_, msg.c_str());
        }
    }

    // 重载通用的operator<<，转发给ostringstream
    template <typename T>
    LogWrapper& operator<<(const T& value) {
        oss_ << value;
        return *this;
    }

    // 处理endl、flush等操纵符
    LogWrapper& operator<<(std::ostream& (*manip)(std::ostream&)) {
        manip(oss_);
        return *this;
    }
};

2. 全局替换cout
   你有两种方式实现全局替换，不用修改业务代码：

• 方式一：在项目的全局头文件里添加宏（确保所有业务代码都包含这个头文件）：

#define cout LogWrapper(__func__)

• 方式二：通过编译选项全局定义宏（更方便，不用改头文件）：
  在编译命令里添加-Dcout=LogWrapper(__func__)，比如：

g++ -Dcout=LogWrapper(__func__) your_source.cpp -o your_program -pthread

这个方案的优势： #

• 无需修改业务代码：所有原来的cout << "xxx" << std::endl;都会自动被替换，完全不用动现有代码。
• 准确获取调用方函数名：__func__宏在构造LogWrapper时被展开，拿到的就是业务代码里调用cout的函数名。
• 多线程安全：每个cout语句都会创建独立的LogWrapper临时对象，ostringstream是线程局部的，只有日志函数需要加锁，不会有竞态问题。
• 无额外线程：所有日志处理都在调用cout的线程内完成，完全符合你“避免额外创建线程”的要求。

额外注意事项 #

• 如果业务代码里有用到std::cout的全名，需要把宏改成#define std::cout LogWrapper(__func__)，或者通过编译选项-Dstd::cout=LogWrapper(__func__)来替换。
• 对于复杂的操纵符（比如std::setw），需要在LogWrapper里补充对应的operator<<重载，不过大部分常用操纵符都能被上面的模板函数处理。
• 如果需要获取更多上下文（比如文件名、行号），可以把宏改成#define cout LogWrapper(__func__, __FILE__, __LINE__)，然后修改LogWrapper的构造函数来接收这些参数。

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