帶前綴的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; 
}