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

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

改变你的输出运营商这应该解决您的问题：

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

Answer 3

正如迪特马尔说，你要的是你自己的流缓冲，某事，这一般顺序：

#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创建一个ostream。然后，您可以写入该ostream，并将您的前缀写入每行输出。例如：

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

    std::ostream out(&buf); 

    out << "Test\n"; 
} 

Answer 4

或者，您可以通过语法更改编写函数。

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