logo标签列表

如何组合输出流，使得输出可以同时发送到多个位置？

c++booststreamiostreamtee
22

我想将两个（或多个）流组合成一个。我的目标是，任何输出指向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;
};

这似乎足够简单。在主函数中的调用可能是这样的：

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

我也看了一下boost::iostreams，但没有发现相关内容。

还有其他更好/更简单的方法吗？

我喜欢这里的答案：https://dev59.com/n2Yr5IYBdhLWcg3wE2Oz#13978705 - feetwet
3个回答
13

如果你想在stdlib内部纯粹完成这个任务，那么你的设计是正确的。

有一件事情：不要在每次输出时都向每个streambuf进行tee操作，而是实现它使用与其给定的一个streambuf相同的放置区域，并在溢出和同步时将其复制到其他streambuf中。这将最小化虚拟调用，这是streambuf工作方式的目标之一。

或者，如果你只想处理stdout和stderr（这很常见），可以通过标准Unix tee程序（或平台上的等效程序）运行程序，通过在调用程序时自己执行或在程序内部进行分叉，设置适当的流等来完成。

编辑： 你让我开始思考，我应该知道如何做对。这是我的第一个近似值。（当它坏掉时，你需要保留两个部分。）

#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;
}
1
所以我也实现了我的代码，我们的代码相当接近，尽管我将我的代码分成了两个类（一个是tee的streambufs，另一个是tee的streams，使用前者的tee）。然而，Eric指出boost已经实现了这一点，所以如果我能让他的代码按照我希望的方式工作，我会接受他的答案。但你应该知道这篇文章非常有帮助，我从中学到了很多。 :) - GManNickG
不错的解决方案！非损坏链接：https://bitbucket.org/kniht/scraps/src/01ecc1346bc5/cpp/kniht/streamtee.hpp - Ben Hymers
好的，我来晚了，但是那个包含保护是什么？？？只用 #ifndef FILENAME_H 不行吗？ - Oscar
12
我会编写一个自定义的流缓冲区，只需将数据转发到所有链接流的缓冲区即可。
#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));

            // In C++20 we can simplify this:
            // Thanks: @nabelekt
            for (auto& buf: bufs) {
                buf->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";
}
1
错误在于 bind2nd 需要 functional，并且 ostream 需要在构造函数中用 &myBuffer 初始化。 - GManNickG
@GMan：不，你不能使用&myBuffer构造ostream。因为在调用ostream构造函数时，mybuffer尚未被构造。因此，必须在创建ostream后调用rdbuf()来设置缓冲区。当然，有一些方法可以解决这个问题，比如使用ComposeBuffer对象的动态创建，但这比这段代码需要的工作还要多。已更新以包括<functional>。 - Martin York
这似乎直到关闭文件才将任何内容刷新到输出文件中？ - NPike
@NPike：大多数流都是缓冲的。因此，刷新的三种方法是填充缓冲区、关闭流或手动刷新它。或者不使用缓冲流。有关更多信息，请参见std::flush和std::endl。 - Martin York
@Martin，那么 out << "Test" << std::endl; 会导致缓冲区刷新到文件中吗？有没有快速的方法使其使用无缓冲流？ - NPike
显示剩余7条评论
12

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

不幸的是，它与 std::ostream 不兼容 - 不能将其传递给需要 ostream 的函数。 - Timmmm
@Timmmm 它不是一个 ostream，但可以使用 "stream" 适配成一个。 - Éric Malenfant
网页内容由stack overflow 提供, 点击上面的
可以查看英文原文，
原文链接