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_traits<cT> >
class basic_nullbuf: public std::basic_streambuf<cT, traits> {
typename traits::int_type overflow(typename traits::int_type c)
{
return traits::not_eof(c); // indicate success
}
};

template <class cT, class traits = std::char_traits<cT> >
class basic_onullstream: public std::basic_ostream<cT, traits> {
public:
basic_onullstream():
std::basic_ios<cT, traits>(&m_sbuf),
std::basic_ostream<cT, traits>(&m_sbuf)
{
init(&m_sbuf);
}

private:
basic_nullbuf<cT, traits> m_sbuf;
};

typedef basic_onullstream<char> onullstream;
typedef basic_onullstream<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::overflow member. use that one. :)

[Angel Tsankov]

"Thomas Tutone" <Th***********@yahoo.com> wrote in message
news:11**********************@g47g2000cwa.googlegr oups.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_traits<cT> >
class basic_nullbuf: public std::basic_streambuf<cT, traits> {
typename traits::int_type overflow(typename traits::int_type c)
{
return traits::not_eof(c); // indicate success
}
};

template <class cT, class traits = std::char_traits<cT> >
class basic_onullstream: public std::basic_ostream<cT, traits> {
public:
basic_onullstream():
std::basic_ios<cT, traits>(&m_sbuf),
std::basic_ostream<cT, traits>(&m_sbuf)
{
init(&m_sbuf);
}

private:
basic_nullbuf<cT, traits> m_sbuf;
};

typedef basic_onullstream<char> onullstream;
typedef basic_onullstream<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.googlegr oups.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_traits<cT> >
class basic_nullbuf: public std::basic_streambuf<cT, traits> {
typename traits::int_type overflow(typename traits::int_type c)
{
return traits::not_eof(c); // indicate success
}
};

template <class cT, class traits = std::char_traits<cT> >
class basic_onullstream: public std::basic_ostream<cT, traits> {
public:
basic_onullstream():
std::basic_ios<cT, traits>(&m_sbuf),
std::basic_ostream<cT, traits>(&m_sbuf)
{
init(&m_sbuf);
}

private:
basic_nullbuf<cT, traits> m_sbuf;
};

typedef basic_onullstream<char> onullstream;
typedef basic_onullstream<wchar_t> wonullstream;

Best regards,

Tom

May I save the call init(&m_sbuf); in basic_onullstream'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.googlegr oups.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_traits<cT> >
class basic_nullbuf: public std::basic_streambuf<cT, traits> {
typename traits::int_type overflow(typename traits::int_type c)
{
return traits::not_eof(c); // indicate success
}
};

template <class cT, class traits = std::char_traits<cT> >
class basic_onullstream: public std::basic_ostream<cT, traits> {
public:
basic_onullstream():
std::basic_ios<cT, traits>(&m_sbuf),
std::basic_ostream<cT, traits>(&m_sbuf)
{
init(&m_sbuf);
}

private:
basic_nullbuf<cT, traits> m_sbuf;
};

typedef basic_onullstream<char> onullstream;
typedef basic_onullstream<wchar_t> wonullstream;

Best regards,

Tom

May I save the call init(&m_sbuf); in basic_onullstream'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_onullstream()
{
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.googlegr oups.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_traits<cT> >
class basic_nullbuf: public std::basic_streambuf<cT, traits> {
typename traits::int_type overflow(typename traits::int_type c)
{
return traits::not_eof(c); // indicate success
}
};

template <class cT, class traits = std::char_traits<cT> >
class basic_onullstream: public std::basic_ostream<cT, traits> {
public:
basic_onullstream():
std::basic_ios<cT, traits>(&m_sbuf),
std::basic_ostream<cT, traits>(&m_sbuf)
{
init(&m_sbuf);
}

private:
basic_nullbuf<cT, traits> m_sbuf;
};

typedef basic_onullstream<char> onullstream;
typedef basic_onullstream<wchar_t> wonullstream;

Best regards,

Tom

May I save the call init(&m_sbuf); in basic_onullstream'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_onullstream()
{
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.

[John Harrison]

Angel Tsankov wrote:

"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.googlegr oups.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_traits<cT> >
class basic_nullbuf: public std::basic_streambuf<cT, traits> {
typename traits::int_type overflow(typename traits::int_type c)
{
return traits::not_eof(c); // indicate success
}
};

template <class cT, class traits = std::char_traits<cT> >
class basic_onullstream: public std::basic_ostream<cT, traits> {
public:
basic_onullstream():
std::basic_ios<cT, traits>(&m_sbuf),
std::basic_ostream<cT, traits>(&m_sbuf)
{
init(&m_sbuf);
}

private:
basic_nullbuf<cT, traits> m_sbuf;
};

typedef basic_onullstream<char> onullstream;
typedef basic_onullstream<wchar_t> wonullstream;

Best regards,

Tom
May I save the call init(&m_sbuf); in basic_onullstream'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_onullstream()
{
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?

Right, but the code above is exactly equivalent to this

basic_onullstream() : std::basic_ios<cT, traits>()
{
init(&m_sbuf);
}

in other words the default constructor of the virtual base class will be
called automatically if you don't explicitly specify a different
constructor.

john

[Angel Tsankov]

>>>>

May I save the call init(&m_sbuf); in basic_onullstream'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_onullstream()
{
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?

Right, but the code above is exactly equivalent to this

basic_onullstream() : std::basic_ios<cT, traits>()
{
init(&m_sbuf);
}

in other words the default constructor of the virtual base class
will be called automatically if you don't explicitly specify a
different constructor.

john

Yes, I totally agree with you on this point. Anyway, could tou tell us
the reasons you prefer to change the initializer list but keep init?

[John Harrison]

>

Yes, I totally agree with you on this point. Anyway, could tou tell us
the reasons you prefer to change the initializer list but keep init?

Nothing deep, it's just when I write code like this

template <class cT, class traits = std::char_traits<cT> >
class basic_onullstream: public std::basic_ostream<cT, traits> {
public:
basic_onullstream():
std::basic_ios<cT, traits>(&m_sbuf),
std::basic_ostream<cT, traits>(&m_sbuf)
{
}

my compiler warns me about using pointers to as yet unconstructed
objects. If the basic_ios or basic_ostream constructors were to
dereference the pointer it would be undefined behaviour. They don't of
course but my compiler doesn't know that so I get the warning.

john

[Angel Tsankov]

>>

Yes, I totally agree with you on this point. Anyway, could tou tell
us the reasons you prefer to change the initializer list but keep
init?

Nothing deep, it's just when I write code like this

template <class cT, class traits = std::char_traits<cT> >
class basic_onullstream: public std::basic_ostream<cT, traits> {
public:
basic_onullstream():
std::basic_ios<cT, traits>(&m_sbuf),
std::basic_ostream<cT, traits>(&m_sbuf)
{
}

my compiler warns me about using pointers to as yet unconstructed
objects. If the basic_ios or basic_ostream constructors were to
dereference the pointer it would be undefined behaviour. They don't
of course but my compiler doesn't know that so I get the warning.

john

What compiler are you using?