带前缀的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;
}