带前缀的 C++ cout

Question

我想要一个在 cout 上重定向的每行开头都有一个前缀的 ostream； 我试试这个：

#include <iostream>
#include <thread>
class parallel_cout : public std::ostream
{
public:
parallel_cout(std::ostream& o):out(o){}

template <typename T>
std::ostream& operator<< (const T& val)
{
    out << "prefix " << val;
    return *this;
}

std::ostream& out;

};

int main()
{
 parallel_cout pc(std::cout);
 pc<<"a\nb"<<"c\n";
}

但我有输出

prefix a
b

没有c。为什么会这样？

Answer 1

您修改std::ostream 行为的方式是不是通过重载任何输出运算符！相反，您从std::streambuf 派生一个类并覆盖virtual 函数overflow() 和sync()。在您的情况下，您可能会创建一个过滤流缓冲区，即，您将另一个 std::streambuf 作为参数并将经过某种方式修改的字符流写入此流缓冲区。

这是一个简单的例子：

#include <iostream>

class prefixbuf
    : public std::streambuf
{
    std::string     prefix;
    std::streambuf* sbuf;
    bool            need_prefix;

    int sync() {
        return this->sbuf->pubsync();
    }
    int overflow(int c) {
        if (c != std::char_traits<char>::eof()) {
            if (this->need_prefix
                && !this->prefix.empty()
                && this->prefix.size() != this->sbuf->sputn(&this->prefix[0], this->prefix.size())) {
                return std::char_traits<char>::eof();
            }
            this->need_prefix = c == '\n';
        }
        return this->sbuf->sputc(c);
    }
public:
    prefixbuf(std::string const& prefix, std::streambuf* sbuf)
        : prefix(prefix)
        , sbuf(sbuf)
        , need_prefix(true) {
    }
};

class oprefixstream
    : private virtual prefixbuf
    , public std::ostream
{
public:
    oprefixstream(std::string const& prefix, std::ostream& out)
        : prefixbuf(prefix, out.rdbuf())
        , std::ios(static_cast<std::streambuf*>(this))
        , std::ostream(static_cast<std::streambuf*>(this)) {
    }
};

int main()
{
    oprefixstream out("prefix: ", std::cout);
    out << "hello\n"
        << "world\n";
}

流缓冲区在概念上保留一个内部缓冲区，但是，在上面的示例中没有设置。每当一个字符没有空间写入输出缓冲区时，virtual 函数overflow() 就会被一个字符调用（它也可以用特殊值std::char_traits<char>::eof() 调用，它通常用于刷新缓冲）。由于没有缓冲区，overflow() 将为每个字符调用。这个函数所做的就是看它是否需要写一个前缀，如果需要，写prefix。如果写入换行符'\n'，函数会记住如果写入另一个字符，它需要写入prefix。然后它只是将字符的写入转发到底层流缓冲区。

virtual 函数sync() 用于将流与其外部表示同步。对于保留缓冲区的流缓冲区，它确保写入任何缓冲区。由于prefixbuf 并没有真正保留缓冲区，它所要做的就是通过调用pubsync() 将sync() 请求委托给底层流缓冲区。

Answer 2

正如 Dietmar 所说，你想要的是你自己的 streambuf，按照这个一般顺序：

#include <streambuf>
#include <iostream>

class prefixer: public std::streambuf {
public:
    prefixer(std::streambuf* s): sbuf(s) {}
    ~prefixer() { overflow('\n'); }
private:
    typedef std::basic_string<char_type> string;

    int_type overflow(int_type c) {

        if (traits_type::eq_int_type(traits_type::eof(), c))
            return traits_type::not_eof(c);
        switch (c) {
        case '\n':
        case '\r':  {
            prefix = "[FIX]";
            buffer += c;
            if (buffer.size() > 1)
                sbuf->sputn(prefix.c_str(), prefix.size());
            int_type rc = sbuf->sputn(buffer.c_str(), buffer.size());
            buffer.clear();
            return rc;
        }
        default:
            buffer += c;
            return c;
        }
    }

    std::string prefix;
    std::streambuf* sbuf;
    string buffer;
};

要使用它，您可以从其他一些 streambuf（定义它要写入的位置）创建它的一个实例，然后（通常）使用这个 streambuf 创建一个 ostream。然后您可以写入该 ostream，并且您的前缀将写入每一行输出。例如：

int main() { 
    prefixer buf(std::cout.rdbuf());

    std::ostream out(&buf);

    out << "Test\n";
}

Answer 3

您也可以编写一个函数，尽管语法发生变化。

template<typename T>
void print(T content)
{
    cout<<whatever your prefix is;
    cout<<content;
}

Answer 4

您的输出运算符正在返回对基类 (std::ostream) 的引用，这意味着对 operator << 的下一次调用将不会使用您的实现。

将您的输出运算符更改为此应该可以解决您的问题：

template <typename T>
parallel_cout& operator<< (const T& val)
{
    out << "prefix " << val;
    return *this;
}