Dafür eignet es sich ja am besten, direkt auf Buffer ebene zu arbeiten:

#include <streambuf>

template<typename _elem, typename _traits = std::char_traits<_elem> >
class basic_dualstreambuf : public std::basic_streambuf<_elem, _traits >
{
    std::basic_streambuf<_elem, _traits>*        m_first;
    std::basic_streambuf<_elem, _traits>*        m_second;

protected:
    typedef typename _traits traits_t;
	typedef typename traits_t::int_type int_t;

    virtual int_t overflow(int_t c = traits_t::eof())
    {
        if (traits_t::eq_int_type(c, traits_t::eof()) == true) return traits_t::not_eof(c);
        c = m_first->sputc(c);
	return (traits_t::eq_int_type(c, traits_t::eof()) == false ? m_second->overflow() : c);
    }

    virtual int sync()
    { return (m_first->sync() != -1 ? m_second->sync() : -1); }

public:
    explicit two_streambuf (std::basic_streambuf<_elem, _traits>* ptr_first, std::basic_streambuf<_elem, _traits>* ptr_second)
        : m_first(ptr_first), m_second(ptr_second)
    {}
};

typedef basic_dualstreambuf<char> dualstreambuf;
typedef basic_dualstreambuf<wchar_t> wdualstreambuf;

. Da meckert der VC++ 2005 aber:

_console_test_project.h(187) : error C2248: 'std::basic_streambuf<_Elem,_Traits>::overflow' : cannot access protected member declared in class 'std::basic_streambuf<_Elem,_Traits>'
        with
        [
            _Elem=char,
            _Traits=std::char_traits<char>
        ]
        c:\programme\microsoft visual studio 8\vc\include\streambuf(297) : see declaration of 'std::basic_streambuf<_Elem,_Traits>::overflow'
        with
        [
            _Elem=char,
            _Traits=std::char_traits<char>
        ]
        _console_test_project.h(184) : while compiling class template member function 'int basic_dualstreambuf<_elem>::overflow(int)'
        with
        [
            _elem=char
        ]
        _console_test_project.h(203) : see reference to class template instantiation 'basic_dualstreambuf<_elem>' being compiled
        with
        [
            _elem=char
        ]

wenn ich es bsw. mal so teste:

#include <fstream>
#include <iostream>

int main()
{
	std::ofstream file_stream("test.txt");
	dualstreambuf buffer(std::cout.rdbuf(), file_stream.rdbuf());
	std::clog.rdbuf(&buffer);
	std::cout << "Test 001" << std::endl;
}

. Jemand eine Idee wie ich das umgehen kann?

Hab mich nach meinem ersten Versuch (s. oben) mal schlau gemacht aber auch nur gefunden, dass overflow überladen werden muss ... und das hab ich ja nunmal versucht

Vlg Deviloper

Das ganze könnte etwa so laufen:

virtual int_t overflow( int_t c = traits_t::eof() )
    {
        if (traits_t::eq_int_type(c, traits_t::eof())) 
            return traits_t::not_eof(c);
        const char cc = traits_t::to_char_type( c );
        return (traits_t::eq_int_type( m_first->sputc(cc), traits_t::eof() )
            || traits_t::eq_int_type( m_second->sputc(cc), traits_t::eof() ))? traits_t::eof(): traits_t::not_eof(c);
    }

    virtual int sync()
    { return (m_first->pubsync() == 0 && m_second->pubsync() == 0? 0: -1); }

Im übrigen solltest Du die Buffer immer wieder zurücksetzen - insbesondere den von clog.

Das hatten wir auch schon mal .. hier ist so eine Weiche implementiert. Die Weiche übernimmt auch das Rücksetzen.

Gruß
Werner

das lässt dir zwei alternativen.
(a) du moppelst doppelt und bufferst die ausgabe deines streambufs nochmal auf den beiden streambufs, die du als zeiger verwendest (damit ist dein streambuf so eine art proxy-stream), du kannst natürlich den internen buffer deiner streambufs auf 0 setzen, dann hast du de facto auch nur mehr einen buffer. //anmerkung: sehe gerade, das Werner Salomon genau so etwas vorschlägt
(b) du schreibst dir eine eigene streamklasse, die zwei streambufs für die ausgabe verwendet.

PS namen mit einem unterstrich beginnen zu lassen ist böse!

... warum wird nur ein verdammtes Zeichen angehangen? Da stimmt doch was nicht

vielleicht hilft dir einer der beiden links weiter:
http://spec.winprog.org/streams/
http://www.icce.rug.nl/documents/cplusplus/cplusplus05.html

Meep Meep