null ostream?

[Angel Tsankov]

How do I define a null ostream that inherits publicly std::ostream and
ignores anything that would otherwise be output?

[Mark P]

Angel Tsankov wrote:

How do I define a null ostream that inherits publicly std::ostream and
ignores anything that would otherwise be output?

You could create an ofstream that writes to /dev/null
Not portable, but easy :)

[Thomas Tutone]

Angel Tsankov wrote:

How do I define a null ostream that inherits publicly std::ostream and
ignores anything that would otherwise be output?

I cribbed this from c.l.c++ years ago - don't remember the original
author (but it's not me):

#include <streambuf>
#include <ostream>

template <class cT, class traits = std::char_trait s<cT> >
class basic_nullbuf: public std::basic_stre ambuf<cT, traits> {
typename traits::int_typ e overflow(typena me traits::int_typ e c)
{
return traits::not_eof (c); // indicate success
}
};

template <class cT, class traits = std::char_trait s<cT> >
class basic_onullstre am: public std::basic_ostr eam<cT, traits> {
public:
basic_onullstre am():
std::basic_ios< cT, traits>(&m_sbuf ),
std::basic_ostr eam<cT, traits>(&m_sbuf )
{
init(&m_sbuf);
}

private:
basic_nullbuf<c T, traits> m_sbuf;
};

typedef basic_onullstre am<char> onullstream;
typedef basic_onullstre am<wchar_t> wonullstream;

Best regards,

Tom

[peter steiner]

try this:

#include <iostream>

struct null_streambuf
: public std::streambuf
{
void overflow(char c)
{
}
};

int main()
{
null_streambuf nullbuf;

// replace buffer of existing stream
std::streambuf * origbuf = std::cout.rdbuf (&nullbuf);
std::cout << "this goes into oblivion";
std::cout.rdbuf (origbuf);

// create null ostream
std::ostream out(&nullbuf);
out << "this goes into oblivion too...";
}
-- peter

[peter steiner]

to correct myself, Thomas Tutone's version's author hasn't been too
lazy to ignore non-char character traits and the proper return value of
the streambuf::over flow member. use that one. :)

[Angel Tsankov]

"Thomas Tutone" <Th***********@ yahoo.com> wrote in message
news:11******** **************@ g47g2000cwa.goo glegroups.com.. .

Angel Tsankov wrote:

How do I define a null ostream that inherits publicly std::ostream
and
ignores anything that would otherwise be output?

I cribbed this from c.l.c++ years ago - don't remember the original
author (but it's not me):

#include <streambuf>
#include <ostream>

template <class cT, class traits = std::char_trait s<cT> >
class basic_nullbuf: public std::basic_stre ambuf<cT, traits> {
typename traits::int_typ e overflow(typena me traits::int_typ e c)
{
return traits::not_eof (c); // indicate success
}
};

template <class cT, class traits = std::char_trait s<cT> >
class basic_onullstre am: public std::basic_ostr eam<cT, traits> {
public:
basic_onullstre am():
std::basic_ios< cT, traits>(&m_sbuf ),
std::basic_ostr eam<cT, traits>(&m_sbuf )
{
init(&m_sbuf);
}

private:
basic_nullbuf<c T, traits> m_sbuf;
};

typedef basic_onullstre am<char> onullstream;
typedef basic_onullstre am<wchar_t> wonullstream;

Best regards,

Tom

Thanks, Tom! This seems to be exactly what I need:)

[Angel Tsankov]

"Thomas Tutone" <Th***********@ yahoo.com> wrote in message
news:11******** **************@ g47g2000cwa.goo glegroups.com.. .

Angel Tsankov wrote:

How do I define a null ostream that inherits publicly std::ostream
and
ignores anything that would otherwise be output?

I cribbed this from c.l.c++ years ago - don't remember the original
author (but it's not me):

#include <streambuf>
#include <ostream>

template <class cT, class traits = std::char_trait s<cT> >
class basic_nullbuf: public std::basic_stre ambuf<cT, traits> {
typename traits::int_typ e overflow(typena me traits::int_typ e c)
{
return traits::not_eof (c); // indicate success
}
};

template <class cT, class traits = std::char_trait s<cT> >
class basic_onullstre am: public std::basic_ostr eam<cT, traits> {
public:
basic_onullstre am():
std::basic_ios< cT, traits>(&m_sbuf ),
std::basic_ostr eam<cT, traits>(&m_sbuf )
{
init(&m_sbuf);
}

private:
basic_nullbuf<c T, traits> m_sbuf;
};

typedef basic_onullstre am<char> onullstream;
typedef basic_onullstre am<wchar_t> wonullstream;

Best regards,

Tom

May I save the call init(&m_sbuf); in basic_onullstre am's ctor as this
same call is made in basic_ostream's ctor?

[John Harrison]

Angel Tsankov wrote:

"Thomas Tutone" <Th***********@ yahoo.com> wrote in message
news:11******** **************@ g47g2000cwa.goo glegroups.com.. .

Angel Tsankov wrote:

How do I define a null ostream that inherits publicly std::ostream and
ignores anything that would otherwise be output?

I cribbed this from c.l.c++ years ago - don't remember the original
author (but it's not me):

#include <streambuf>
#include <ostream>

template <class cT, class traits = std::char_trait s<cT> >
class basic_nullbuf: public std::basic_stre ambuf<cT, traits> {
typename traits::int_typ e overflow(typena me traits::int_typ e c)
{
return traits::not_eof (c); // indicate success
}
};

template <class cT, class traits = std::char_trait s<cT> >
class basic_onullstre am: public std::basic_ostr eam<cT, traits> {
public:
basic_onullstre am():
std::basic_ios< cT, traits>(&m_sbuf ),
std::basic_ostr eam<cT, traits>(&m_sbuf )
{
init(&m_sbuf);
}

private:
basic_nullbuf<c T, traits> m_sbuf;
};

typedef basic_onullstre am<char> onullstream;
typedef basic_onullstre am<wchar_t> wonullstream;

Best regards,

Tom

May I save the call init(&m_sbuf); in basic_onullstre am's ctor as this
same call is made in basic_ostream's ctor?

My preference would be to keep init and change the initialiser list

basic_onullstre am()
{
init(&m_sbuf);
}

john

[Angel Tsankov]

"John Harrison" <jo************ *@hotmail.com> wrote in message
news:yN******** *******@newsfe1-gui.ntli.net...

Angel Tsankov wrote:

"Thomas Tutone" <Th***********@ yahoo.com> wrote in message
news:11******** **************@ g47g2000cwa.goo glegroups.com.. .

Angel Tsankov wrote:

How do I define a null ostream that inherits publicly
std::ostream and
ignores anything that would otherwise be output?
I cribbed this from c.l.c++ years ago - don't remember the
original
author (but it's not me):

#include <streambuf>
#include <ostream>

template <class cT, class traits = std::char_trait s<cT> >
class basic_nullbuf: public std::basic_stre ambuf<cT, traits> {
typename traits::int_typ e overflow(typena me traits::int_typ e c)
{
return traits::not_eof (c); // indicate success
}
};

template <class cT, class traits = std::char_trait s<cT> >
class basic_onullstre am: public std::basic_ostr eam<cT, traits> {
public:
basic_onullstre am():
std::basic_ios< cT, traits>(&m_sbuf ),
std::basic_ostr eam<cT, traits>(&m_sbuf )
{
init(&m_sbuf);
}

private:
basic_nullbuf<c T, traits> m_sbuf;
};

typedef basic_onullstre am<char> onullstream;
typedef basic_onullstre am<wchar_t> wonullstream;

Best regards,

Tom

May I save the call init(&m_sbuf); in basic_onullstre am's ctor as
this same call is made in basic_ostream's ctor?

My preference would be to keep init and change the initialiser list

basic_onullstre am()
{
init(&m_sbuf);
}

john

Well, I'm not sure this is a good idea, as ctors of virtual bases must
be called by any derived class ctor, right?

[Maxim Yegorushkin]

Angel Tsankov wrote:

How do I define a null ostream that inherits publicly std::ostream and
ignores anything that would otherwise be output?

You can just set the failbit on any ostream. This makes it effectively
ignore all output sent to it until you unset the bit.