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?

An Ostream is an abstract base class for all output systems (streams, files, token lists.

Answers:

Ostreams support insertion (storing) into a streambuf. These are commonly referred to as output operations. These are commonly referred to as output operations. The ostream member functions and related functions are described below.
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!).

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

Answers:

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:

' : c; }};

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.

Answers:

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

Outputs:

Answers:

C%2b%2b Ostream Dev Null

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

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++

C 2b 2b Ostream Dev Null Test

/* 
# Copyright (C) 2008 David M. Whitney (aka 'dwhitney67') 
# 
# This program is free software: you can redistribute it and/or modify it under 
# the terms of the GNU General Public License as published by the Free Software 
# Foundation, either version 3 of the License, or (at your option) any later 
# version. 
# 
# This program is distributed in the hope that it will be useful, but WITHOUT 
# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS 
# FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. 
# 
# You should have received a copy of the GNU General Public License along with 
# this program. If not, see <http://www.gnu.org/licenses/>. 
*/ 
#include <string> 
#include <vector> 
#include <algorithm> 
#include <stdexcept> 
#include <sstream> 
#include <iostream> 
class ExecCommand 
{ 
 public: 
typedef std::vector<std::string> CmdResults; 
ExecCommand( const std::string &cmd ) 
 { 
FILE *pfd = popen( cmd.c_str(), 'r' ); 
 if ( pfd <= 0 ) 
 { 
 throw std::runtime_error( 'Command or process could not be executed.' ); 
 } 
 while ( !feof(pfd) ) 
 { 
char buf[ 1024 ] = {0}; 
 if ( fgets(buf, sizeof(buf), pfd) > 0 ) 
 { 
std::string str(buf); 
m_results.push_back( str.substr(0, str.length()-1) ); 
 } 
 } 
pclose( pfd ); 
 } 
 const CmdResults getResults() const 
 { 
 return m_results; 
 } 
friend std::ostream & operator<<( std::ostream &os, const ExecCommand &exec ) 
 { 
std::for_each( exec.m_results.begin(), exec.m_results.end(), ExecCommand::Displayer(os) ); 
 return os; 
 } 
 private: 
 class Displayer 
{ 
 public: 
Displayer( std::ostream &os ) : m_os(os) {} 
void operator()( const std::string &str ) 
 { 
m_os << str << std::endl; 
 } 
 private: 
std::ostream &m_os; 
 }; 
CmdResults m_results; 
}; 
int main( int argc, char **argv ) 
{ 
 try 
 { 
std::string cmd; 
 for ( int i = 1; i < arg