如何控制外部库的std::cout输出并同时重定向至文件？

Yes, you absolutely can capture and duplicate all output to std::cout—including output from third-party libraries you can't modify—by replacing the underlying stream buffer (std::streambuf) of std::cout with a custom one that forwards data to two destinations: the original console output and your log file.

How It Works #

std::cout relies on a std::streambuf to handle the actual I/O operations. By creating a custom streambuf that duplicates every character written to it to two separate streambufs (one for the console, one for your log file), you can redirect all output without touching any third-party code.

Step-by-Step Implementation #

1. Create a Custom Dual-Output Streambuf #

First, define a class that inherits from std::streambuf and forwards output to two target buffers:

#include <iostream>
#include <fstream>
#include <streambuf>

class DualOutputBuf : public std::streambuf {
public:
    DualOutputBuf(std::streambuf* console_buf, std::streambuf* file_buf)
        : console_buf_(console_buf), file_buf_(file_buf) {}

protected:
    // Handle single character output
    int overflow(int c) override {
        if (c != EOF) {
            // Write to console
            if (console_buf_->sputc(static_cast<char>(c)) == EOF) {
                return EOF;
            }
            // Write to file
            if (file_buf_->sputc(static_cast<char>(c)) == EOF) {
                return EOF;
            }
        }
        return c;
    }

    // Flush both buffers
    int sync() override {
        if (console_buf_->pubsync() == -1 || file_buf_->pubsync() == -1) {
            return -1;
        }
        return 0;
    }

private:
    std::streambuf* console_buf_;
    std::streambuf* file_buf_;
};

2. Use RAII to Manage the Redirect #

To ensure std::cout is restored to its original state when you're done, wrap the streambuf replacement in an RAII class. This prevents leaving std::cout in an invalid state if an exception is thrown:

class CoutRedirector {
public:
    CoutRedirector(const std::string& log_file_path)
        : log_file_(log_file_path, std::ios::out | std::ios::app),
          dual_buf_(std::cout.rdbuf(), log_file_.rdbuf()),
          original_buf_(std::cout.rdbuf(&dual_buf_)) {}

    ~CoutRedirector() {
        // Restore the original streambuf automatically
        std::cout.rdbuf(original_buf_);
    }

private:
    std::ofstream log_file_;
    DualOutputBuf dual_buf_;
    std::streambuf* original_buf_;
};

3. Integrate into Your Program #

Instantiate the CoutRedirector whenever you want to capture all std::cout output. All writes to std::cout during its lifetime will go to both the console and your log file:

// Example third-party function you can't modify
void third_party_output() {
    std::cout << "This comes from a third-party library!\n";
}

int main() {
    // Start redirecting cout to both console and log file
    CoutRedirector redirector("app_logs.log");

    // Your own LOG macro output
    std::cout << "This is my custom log message\n";

    // Third-party library output gets captured too
    third_party_output();

    // Redirector goes out of scope here, cout is restored to normal
    return 0;
}

Key Notes #

• Universal Capture: This method catches every write to std::cout, no matter where it originates—your code, third-party libraries, even standard library functions like std::endl.
• Safety First: The RAII class ensures std::cout is always restored to its original state, even if an error occurs.
• Flexible File Modes: The example uses append mode (std::ios::app), but you can switch to overwrite mode (std::ios::trunc) if you prefer fresh logs each run.
• Basic Error Handling: The code includes minimal error checking, but you can expand it (e.g., verify the log file opened successfully) for your use case.

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