如何组合输出流，以便输出一次到达多个位置？

Posted 2023-02-25

【中文标题】如何组合输出流，以便输出一次到达多个位置？

【英文标题】：How can I compose output streams, so output goes multiple places at once?

【发布时间】：2010-12-18 03:48:30

【问题描述】：

我想将两个（或多个）流合并为一个。我的目标是任何指向cout、cerr 和clog 的输出也与原始流一起输出到文件中。 （例如，当事情被记录到控制台时。关闭后，我希望仍然能够返回并查看输出。）

我正在考虑做这样的事情：

class stream_compose : public streambuf, private boost::noncopyable

public:
    // take two streams, save them in stream_holder,
    // this set their buffers to `this`.
    stream_compose;

    // implement the streambuf interface, routing to both
    // ...

private:
    // saves the streambuf of an ios class,
    // upon destruction restores it, provides
    // accessor to saved stream
    class stream_holder;

    stream_holder mStreamA;
    stream_holder mStreamB;
;

这似乎很简单。那么 main 中的调用将类似于：

// anything that goes to cout goes to both cout and the file
stream_compose coutToFile(std::cout, theFile);
// and so on

我也查看了boost::iostreams，但没有看到任何相关内容。

还有其他更好/更简单的方法来实现这一点吗？

【问题讨论】：

我喜欢这里的答案：***.com/a/13978705/2662901

【参考方案1】：

如果您想纯粹在标准库中执行此操作，那么您确实有正确的设计。

有一件事：不是在每个输出上对每个流缓冲区进行开球，而是将其实现为使用与它给定的流缓冲区之一相同的放置区域，并在溢出和同步时复制到其他区域。这将最大限度地减少虚拟调用，这是 streambuf 工作方式的目标之一。

或者，如果您只想处理 stdout 和 stderr（这很常见），请通过标准 Unix tee 程序（或您平台上的等效程序）运行您的程序，或者在调用程序时自己执行，或在程序中通过分叉、适当地设置流等。

编辑：你让我思考，我应该知道如何正确处理。这是我的firstapproximation。 （当它破裂时，你可以保留这两部分。）

#ifndef INCLUDE_GUARD_A629F54A136C49C9938CB33EF8EDE676
#define INCLUDE_GUARD_A629F54A136C49C9938CB33EF8EDE676

#include <cassert>
#include <cstring>
#include <streambuf>
#include <map>
#include <vector>

template<class CharT, class Traits=std::char_traits<CharT> >
struct basic_streamtee : std::basic_streambuf<CharT, Traits> 
    typedef std::basic_ios<CharT, Traits> Stream;
    typedef std::basic_streambuf<CharT, Traits> StreamBuf;

    typedef typename StreamBuf::char_type char_type;
    typedef typename StreamBuf::traits_type traits_type;
    typedef typename StreamBuf::int_type int_type;
    typedef typename StreamBuf::pos_type pos_type;
    typedef typename StreamBuf::off_type off_type;

    basic_streamtee() : _key_buf(0) 
    basic_streamtee(Stream& a, Stream& b) : _key_buf(0) 
        this->pubimbue(a.rdbuf()->getloc());
        _set_key_buf(a.rdbuf());
        insert(a);
        insert(b);
    
    ~basic_streamtee() 
        sync();
        for (typename std::map<Stream*, StreamBuf*>::iterator i = _bufs.begin();
             i != _bufs.end();
             ++i)
        
            StreamBuf* old = i->first->rdbuf(i->second);
            if (old != this) 
                old->pubsync();
            
        
    

    // add this functionality?
    // streambufs would be unconnected with a stream
    // easy to do by changing _bufs to a multimap
    // and using null pointers for the keys
    //void insert(StreamBuf* buf);
    //void remove(StreamBuf* buf);

    void insert(Stream& s) 
        sync();
        if (!_bufs.count(&s)) 
            if (!_key_buf) 
                _set_key_buf(s.rdbuf());
            
            _bufs[&s] = s.rdbuf(this);
        
    
    void remove(Stream& s) 
        sync();
        typename std::map<Stream*, StreamBuf*>::iterator i = _bufs.find(&s);
        if (i != _bufs.end()) 
            StreamBuf* old = i->second;
            i->first->rdbuf(i->second);
            _bufs.erase(i);

            if (old == _key_buf) 
                _set_key_buf(_bufs.empty() ? 0 : _bufs.begin()->second);
            
        
    

private:
    basic_streamtee(basic_streamtee const&); // not defined
    basic_streamtee& operator=(basic_streamtee const&); // not defined

    StreamBuf* _key_buf;
    std::map<Stream*, StreamBuf*> _bufs;

    void _set_key_buf(StreamBuf* p) 
        //NOTE: does not sync, requires synced already
        _key_buf = p;
        _update_put_area();
    
    void _update_put_area() 
        //NOTE: does not sync, requires synced already
        if (!_key_buf) 
            this->setp(0, 0);
        
        else 
            this->setp((_key_buf->*&basic_streamtee::pbase)(),
                       (_key_buf->*&basic_streamtee::epptr)());
        
    


#define FOREACH_BUF(var) \
for (typename std::map<Stream*, StreamBuf*>::iterator var = _bufs.begin(); \
var != _bufs.end(); ++var)


    // 27.5.2.4.1 Locales
    virtual void imbue(std::locale const& loc) 
        FOREACH_BUF(iter) 
            iter->second->pubimbue(loc);
        
    


    // 27.5.2.4.2 Buffer management and positioning
    //virtual StreamBuf* setbuf(char_type* s, std::streamsize n); // not required
    //virtual pos_type seekoff(off_type off, std::ios_base::seekdir way,
    //                         std::ios_base::openmode which); // not required
    //virtual pos_type seekpos(pos_type sp, std::ios_base::openmode which); // not required
    virtual int sync() 
        if (!_key_buf) 
            return -1;
        
        char_type* data = this->pbase();
        std::streamsize n = this->pptr() - data;
        (_key_buf->*&basic_streamtee::pbump)(n);
        FOREACH_BUF(iter) 
            StreamBuf* buf = iter->second;
            if (buf != _key_buf) 
                buf->sputn(data, n); //BUG: ignores put errors
                buf->pubsync(); //BUG: ignroes errors
            
        
        _key_buf->pubsync(); //BUG: ignores errors
        _update_put_area();
        return 0;
    


    // 27.5.2.4.3 Get area
    // ignore input completely, teeing doesn't make sense
    //virtual std::streamsize showmanyc();
    //virtual std::streamsize xsgetn(char_type* s, std::streamsize n);
    //virtual int_type underflow();
    //virtual int_type uflow();


    // 27.5.2.4.4 Putback
    // ignore input completely, teeing doesn't make sense
    //virtual int_type pbackfail(int_type c);


    // 27.5.2.4.5 Put area
    virtual std::streamsize xsputn(char_type const* s, std::streamsize n) 
        assert(n >= 0);
        if (!_key_buf) 
            return 0;
        

        // available room in put area? delay sync if so
        if (this->epptr() - this->pptr() < n) 
            sync();
        
        // enough room now?
        if (this->epptr() - this->pptr() >= n) 
            std::memcpy(this->pptr(), s, n);
            this->pbump(n);
        
        else 
            FOREACH_BUF(iter) 
                iter->second->sputn(s, n);
                //BUG: ignores put errors
            
            _update_put_area();
        
        return n;
    
    virtual int_type overflow(int_type c) 
        bool const c_is_eof = traits_type::eq_int_type(c, traits_type::eof());
        int_type const success = c_is_eof ? traits_type::not_eof(c) : c;
        sync();
        if (!c_is_eof) 
            char_type cc = traits_type::to_char_type(c);
            xsputn(&cc, 1);
            //BUG: ignores put errors
        
        return success;
    

#undef FOREACH_BUF
;

typedef basic_streamtee<char> streamtee;
typedef basic_streamtee<wchar_t> wstreamtee;

#endif

现在，这个测试还远未完成，但它似乎有效：

#include "streamtee.hpp"

#include <cassert>
#include <iostream>
#include <sstream>

int main() 
    using namespace std;
    
        ostringstream a, b;
        streamtee tee(a, b);
        a << 42;
        assert(a.str() == "42");
        assert(b.str() == "42");
    
    
        ostringstream a, b;
        streamtee tee(cout, a);
        tee.insert(b);
        a << 42 << '\n';
        assert(a.str() == "42\n");
        assert(b.str() == "42\n");
    
    return 0;

把它和一个文件放在一起：

#include "streamtee.hpp"

#include <iostream>
#include <fstream>

struct FileTee 
  FileTee(std::ostream& stream, char const* filename)
  : file(filename), buf(file, stream)
  

  std::ofstream file;
  streamtee buf;
;

int main() 
  using namespace std;

  FileTee out(cout, "stdout.txt");
  FileTee err(clog, "stderr.txt");
  streambuf* old_cerr = cerr.rdbuf(&err.buf);

  cout << "stdout\n";
  clog << "stderr\n";

  cerr.rdbuf(old_cerr);
  // watch exception safety

  return 0;

【讨论】：

所以我也实现了我的代码，我们的代码相当接近，尽管我将我的代码分为两个类（一个是 tee 的流缓冲区，另一个是 tee 的流，它使用了前一个 tee）。但是，Eric 已经指出 boost 已经实现了这一点，所以如果我能让他按照我希望的方式工作，我会接受他的回答。但是你应该知道这篇文章很有帮助，我从中学到了很多。 :)

不错的解决方案！完整链接：bitbucket.org/kniht/scraps/src/01ecc1346bc5/cpp/kniht/…

好的，所以我在这里超级晚了，但那是什么包括后卫？？？ #ifndef FILENAME_H 有什么问题？

【参考方案2】：

您提到在 Boost.IOStreams 中没有发现任何内容。你考虑过tee_device吗？

【讨论】：

不幸的是，它与 std::ostream 不兼容 - 您不能将它传递给需要 ostream 的函数。

@Timmmm 不是ostream，但可以使用“stream”适配成一个

【参考方案3】：

我会编写一个自定义流缓冲区，它只是将数据转发到所有链接流的缓冲区。

#include <iostream>
#include <fstream>
#include <vector>
#include <algorithm>
#include <functional>

class ComposeStream: public std::ostream

    struct ComposeBuffer: public std::streambuf
    
        void addBuffer(std::streambuf* buf)
        
            bufs.push_back(buf);
        
        virtual int overflow(int c)
        
            std::for_each(bufs.begin(),bufs.end(),std::bind2nd(std::mem_fun(&std::streambuf::sputc),c));
            return c;
        

        private:
            std::vector<std::streambuf*>    bufs;

    ;  
    ComposeBuffer myBuffer;
    public: 
        ComposeStream()
            :std::ostream(NULL)
        
            std::ostream::rdbuf(&myBuffer);
           
        void linkStream(std::ostream& out)
        
            out.flush();
            myBuffer.addBuffer(out.rdbuf());
        
;
int main()

    ComposeStream   out;
    out.linkStream(std::cout);
    out << "To std::cout\n";

    out.linkStream(std::clog);
    out << "To: std::cout and std::clog\n";

    std::ofstream   file("Plop");
    out.linkStream(file);
    out << "To all three locations\n";

【讨论】：

顺便说一句，你有一些错误。实际上，这与我到目前为止的情况相似。问题是我需要做三个，因为我不能将cout 和cerr 相互链接。 （默认情况下它们输出到同一个地方）

为我编译和运行。如果 clog 和 cout 去同一个地方不是 ComposeStream 的问题。

漂亮而简单。但是，它不允许已经使用 cout/clog/etc 的代码。将它们的输出放入组合流中。 （这当然可能是一个好处，但这不是我所要求的，我阅读它的方式。）

cout 和 cerr 没有相互链接，除非您的实现这样做。一个写入stdout，另一个写入stderr。 clog 和 cerr 都写到 stderr，这是你的意思吗？

错误是bind2nd需要functional，而ostream需要在构造函数中初始化为&myBuffer