Thread: "Spying" on cout

Is this within the program itself (I'm confused, you said you couldn't modify the code)?

Even if it's not 'tee', you can still manipulate the streams from the outside in other ways similar to pipes.

Also, say which OS / Compiler you're using.

I'm guessing that the teebuf thing might be compiler specific, and that you need to fiddle it to make it work for you.

I don't think you need to directly call overflow or sync on your class members (I'm less sure about the latter--and I don't think you even need to define a sync function unless you're buffering the output)

Something like this might work:

Code:

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

template <class charT, class destbuf_type = std::streambuf, class srcbuf_type = std::streambuf, class traits = std::char_traits<charT> >
class copy_outbuf: public std::basic_streambuf<charT, traits>
{
public:
  copy_outbuf(srcbuf_type* src, destbuf_type* dest):m_srcBuf(src),m_destBuf(dest){}
protected:
  virtual int_type overflow(int_type c)
  {
    if (!traits::eq_int_type(c,traits::eof()))
    {
      if (m_srcBuf->sputc(c) == traits::eof()) //error occurred
        return traits::eof();
      if (m_destBuf->sputc(c) == traits::eof())
        return traits::eof();
    }
    return traits::not_eof(c);
  }
  virtual std::streamsize xsputn(const charT* s, std::streamsize num)
  {
    std::streamsize written = m_srcBuf->sputn(s,num);
    m_destBuf->sputn(s,written);
    return written;
  }
private:
  srcbuf_type* m_srcBuf;
  destbuf_type* m_destBuf;
};

int main()
{
  std::ofstream outfile("test.txt");
  copy_outbuf<char> new_buf(std::cout.rdbuf(),outfile.rdbuf());
  std::cout.rdbuf(&new_buf);
  std::cout<<"Hello World!";
  std::cout<<'h';
}