Punchblog430

1. C 2b 2b Ostream Dev Null Key
2. C 2b 2b Ostream Dev Null Command
3. C 2b 2b Ostream Dev Null Code

I’m looking for a std::ostream implementation that acts like /dev/null. It would just ignore anything that is streamed to it. Does such a thing exist in the standard libraries or Boost? Or do I have to roll my own?

To define the ostream class in C sources, the ostream header file must be included. To use the predefined ostream objects (std::cerr, std::cout etc.) the header file must be included. 6.4.1.1: Writing to `ostream' objects The class ostream supports both formatted and binary output. Them ofstream('/dev/null') but this makes my program less portable. Is there a null ostream built in cpp? Is it easy to implement one? You can try o.clear(ios::failbit), and then any statement o NULL in case someone calls o.rdbuf and writes to the buffer directly. I combined three different proposals above and one writing directly to /dev/null (so it involves kernel.) Surprisingly the NullStream that got the most votes performed the worst. Here are results for 100,000,000 writes: a) /dev/null: 30 seconds b) NullStream: 50 seconds c) badbit: 16 seconds (the winner in speed, but cannot test for errors!).

C opens the istream object cin when the program starts. Similarly, ostream is the basis for output. The prototypes above are for inserters and extractors for pointers to null terminated character strings (like “My name”), for string objects, for ints, and for doubles.

C 2b 2b Ostream Dev Null Key

If you have boost, then there’s a null ostream & istream implementation available in boost/iostreams/device/null.hpp . The gist of it:

The simplest solution is just to use an unopened std::ofstream. This
will result in an error state in the stream, but most outputters won’t
check this; the usual idiom is to leave the check to the end, after the
close (which would put it in code you wrote, where you know that the
stream should be invalid).

Otherwise, it’s pretty straight forward to implement: just create a
streambuf which contains a small buffer, and sets it up in overflow
(always returning success). Note that this will be slower than the
unopened file, however; the various >> operators will still to all of
the conversion (which they don’t do if the stream has an error state).

EDIT:

It’s usual to provide a convenience class derived from istream
or ostream as well, which will contain an instance of this
buffer which it uses. Something along the lines of:

Or you can just use an std::ostream, passing the address of
the streambuf to it.

If you set badbit on a stream it won’t output anything:

Outputs:

I know this is very old thread, but I would like to add this to anyone who is looking for the same solution without boost and and the fastest one.

I combined three different proposals above and one writing directly to /dev/null (so it involves kernel.)

Surprisingly the NullStream that got the most votes performed the worst.

Here are results for 100,000,000 writes:

Here is the test code

EDIT

C 2b 2b Ostream Dev Null Command

C 2b 2b Ostream Dev Null Code

The fastest solution – where we use badbit – has a downside. If the program checks if the output is successfully written – and I have no idea why the program should not do that – then it will fail because of this badbit.
Therefore, the runner up – bost – is the winner.

Tags: c++