Comment faire pour hériter de std::ostream?

Je filais ma tête autour de la façon de faire la même chose et j'ai trouvé qu'il n'est pas difficile.
Fondamentalement, il suffit de la sous-classe ostream et le streambuf objets, et la construction de la ostream avec lui-même comme une zone tampon. le virtuel débordement() à partir de std::streambuf sera appelée pour chaque caractère envoyé dans le flux. Pour s'adapter à votre exemple, j'ai juste fait un foo() et la fonction appelée.

struct Bar : std::ostream, std::streambuf
{
    Bar() : std::ostream(this) {}

    int overflow(int c)
    {
        foo(c);
        return 0;
    }


    void foo(char c)
    {
        std::cout.put(c);

    }
};

void main()
{
    Bar b;
    b<<"Look a number: "<<std::hex<<29<<std::endl;
}

oh et ignorer le fait que la fonction principale n'est pas une vraie fonction principale. C'est dans un espace de noms appelé d'ailleurs ;p

Je ne sais pas si c'est la bonne solution, mais j'ai hérité de std::ostream de cette façon. Il utilise une mémoire tampon hérité de std::basic_streambuf et obtient 64 caractères (ou moins si rincé) et les envoie à un générique putChars() la méthode la manipulation des données est effectuée. Il montre également comment donner à l'utilisateur des données.

Live Exemple

#include <streambuf>
#include <ostream>
#include <iostream>
//#define DEBUG
class MyData
{
//example data class, not used
};
class MyBuffer : public std::basic_streambuf<char, std::char_traits<char> >
{
public:
inline MyBuffer(MyData data) :
data(data)
{
setp(buf, buf + BUF_SIZE);
}
protected:
//This is called when buffer becomes full. If
//buffer is not used, then this is called every
//time when characters are put to stream.
inline virtual int overflow(int c = Traits::eof())
{
#ifdef DEBUG
std::cout << "(over)";
#endif
//Handle output
putChars(pbase(), pptr());
if (c != Traits::eof()) {
char c2 = c;
//Handle the one character that didn't fit to buffer
putChars(&c2, &c2 + 1);
}
//This tells that buffer is empty again
setp(buf, buf + BUF_SIZE);
return c;
}
//This function is called when stream is flushed,
//for example when std::endl is put to stream.
inline virtual int sync(void)
{
//Handle output
putChars(pbase(), pptr());
//This tells that buffer is empty again
setp(buf, buf + BUF_SIZE);
return 0;
}
private:
//For EOF detection
typedef std::char_traits<char> Traits;
//Work in buffer mode. It is also possible to work without buffer.
static const size_t BUF_SIZE = 64;
char buf[BUF_SIZE];
//This is the example userdata
MyData data;
//In this function, the characters are parsed.
inline void putChars(const char* begin, const char* end){
#ifdef DEBUG
std::cout << "(putChars(" << static_cast<const void*>(begin) <<
"," << static_cast<const void*>(end) << "))";
#endif
//just print to stdout for now
for (const char* c = begin; c < end; c++){
std::cout << *c;
}
}
};
class MyOStream : public std::basic_ostream< char, std::char_traits< char > >
{
public:
inline MyOStream(MyData data) :
std::basic_ostream< char, std::char_traits< char > >(&buf),
buf(data)
{
}
private:
MyBuffer buf;
};
int main(void)
{
MyData data;
MyOStream o(data);
for (int i = 0; i < 8; i++)
o << "hello world! ";
o << std::endl;
return 0;
}