que - ¿Hay una implementación null std:: ostream en C++ o bibliotecas?

librerias de c++

Question

Estoy buscando una implementación std::ostream que actúe como /dev/null . Simplemente ignoraría todo lo que se transmita a él. ¿Existe tal cosa en las bibliotecas estándar o Boost? ¿O tengo que hacer mi propio?

Answer 1

La solución más simple es solo usar un std::ofstream sin abrir. Esto dará como resultado un estado de error en la transmisión, pero la mayoría de los productores no verificará esto; el modismo habitual es dejar el cheque hasta el final, después del cierre (que lo pondría en el código que escribió, donde sabe que la transmisión no debería ser válida).

De lo contrario, es bastante sencillo de implementar: simplemente crea un streambuf que contenga un pequeño buffer, y lo configura en overflow (siempre regresando al éxito). Sin embargo, tenga en cuenta que esto será más lento que el archivo sin abrir; los diversos operadores >> quedarán con toda la conversión (lo que no hacen si la transmisión tiene un estado de error).

EDITAR:

class NulStreambuf : public std::streambuf
{
    char                dummyBuffer[ 64 ];
protected:
    virtual int         overflow( int c ) 
    {
        setp( dummyBuffer, dummyBuffer + sizeof( dummyBuffer ) );
        return (c == traits_type::eof()) ? ''/0'' : c;
    }
};

Es habitual proporcionar una clase de conveniencia derivada de istream o istream también, que contendrá una instancia de este búfer que utiliza. Algo como:

class NulOStream : private NulStreambuf, public std::ostream
{
public:
    NulOStream() : std::ostream( this ) {}
    NulStreambuf* rdbuf() const { return this; }
};

O simplemente puede usar un std::ostream , pasando la dirección del streambuf a él.

Answer 2

Sé que este es un hilo muy viejo, pero me gustaría agregar esto a cualquiera que esté buscando la misma solución sin impulso y la más rápida.

Combiné tres propuestas diferentes arriba y una escribiendo directamente a / dev / null (por lo que implica kernel).

Sorprendentemente, el NullStream que obtuvo la mayor cantidad de votos realizó el peor.

Aquí hay resultados para 100,000,000 escribe:

a) /dev/null : 30 seconds
b) NullStream: 50 seconds
c) badbit    : 16 seconds (the winner in speed, but cannot test for errors!)
d) boost     : 25 seconds (the ultimate winner)

Aquí está el código de prueba

#include <iostream>
#include <fstream>
#include <time.h>
#include <boost/iostreams/stream.hpp>

class NullStream : public std::ostream {
    class NullBuffer : public std::streambuf {
    public:
        int overflow( int c ) { return c; }
    } m_nb;
public:
    NullStream() : std::ostream( &m_nb ) {}
};

int test( std::ostream& ofs, const char* who ) {
    const time_t t = time(NULL);
    for ( int i = 0 ; i < 1000000000 ; i++ )
        ofs << "Say the same" ;
    std::cout << who << ": " << time(NULL) - t << std::endl;
}

void devnull() {
    std::ofstream ofs;
    ofs.open( "/dev/null", std::ofstream::out | std::ofstream::app );
    test(ofs, __FUNCTION__);
    ofs.close();
}

void nullstream() {
    NullStream ofs;
    test(ofs, __FUNCTION__);
}

void badbit() {
    std::ofstream ofs;
    ofs.setstate(std::ios_base::badbit);
    test(ofs, __FUNCTION__);
}

void boostnull() {
    boost::iostreams::stream< boost::iostreams::null_sink > nullOstream( ( boost::iostreams::null_sink() ) );
    test(nullOstream, __FUNCTION__);
}

int main() {
    devnull();
    nullstream();
    badbit();
    boostnull();
    return 0;
}

EDITAR

La solución más rápida, donde usamos Badbit, tiene una desventaja. Si el programa comprueba si la salida está escrita correctamente y no tengo idea de por qué el programa no debería hacer eso, entonces fallará debido a este badbit. Por lo tanto, el finalista - bost - es el ganador.

Answer 3

Si configura badbit en una transmisión, no generará nada:

#include <iostream>

int main() {
    std::cout << "a/n";

    std::cout.setstate(std::ios_base::badbit);
    std::cout << "b/n";

    std::cout.clear();
    std::cout << "c/n";
}

Productos:

a
c

Answer 4

Si tiene boost, entonces hay una implementación nula de ostream & istream disponible en boost / iostreams / device / null.hpp. La esencia de esto:

#include "boost/iostreams/stream.hpp"
#include "boost/iostreams/device/null.hpp"
...
boost::iostreams::stream< boost::iostreams::null_sink > nullOstream( ( boost::iostreams::null_sink() ) );
...