¿Cómo funciona QDebug() << cosas; agregar una nueva línea automáticamente?

Question

Estoy tratando de poner en práctica mi propio flujo de depuración-salida QDebug() estilo, esto es básicamente lo que tengo hasta ahora:

struct debug 
{ 
#if defined(DEBUG) 
    template<typename T> 
    std::ostream& operator<<(T const& a) const 
    { 
     std::cout << a; 
     return std::cout; 
    } 
#else 
    template<typename T> 
    debug const& operator<<(T const&) const 
    { 
     return *this; 
    } 

    /* must handle manipulators (endl) separately: 
    * manipulators are functions that take a stream& as argument and return a 
    * stream& 
    */ 
    debug const& operator<<(std::ostream& (*manip)(std::ostream&)) const 
    { 
     // do nothing with the manipulator 
     return *this; 
    } 
#endif 
}; 

uso típico:

debug() << "stuff" << "more stuff" << std::endl; 

pero me gustaría no tener que agregar std :: endl;

Mi pregunta es, básicamente, ¿cómo puedo saber cuando el tipo de retorno del operador < < no va a ser utilizado por otro operador < < (y esto añadir endl)?

La única forma en que puedo pensar para lograr algo como esto sería crear una lista de cosas para imprimir con cada objeto temporal creado por debug(), luego imprimir todo, junto con la línea nueva final (y yo podría hacer cosas ingeniosas como insertar espacios) en ~ debug(), pero obviamente esto no es ideal ya que no tengo la garantía de que el objeto temporal vaya a ser destruido hasta el final del alcance (¿o no?).

Answer 1

Qt utiliza un método similar al @ Evan.Consulte a version of qdebug.h para conocer los detalles de la implementación, pero ellos transmiten todo a una secuencia de texto subyacente, y luego descargan la secuencia y una línea final sobre la destrucción del objeto QDebug temporal devuelto por qDebug().

Answer 2

Se supone que la inserción de la secuencia (<<) y la extracción (>>) no son miembros.

Mi pregunta es, básicamente, cómo puedo decir cuando el tipo de retorno de operador < < no va a ser utilizado por otro operador < < (y esto añadir endl)?

No puede. Cree una función de miembro para anexarlo especialmente o anexar un endl una vez que las llamadas encadenadas hayan finalizado. Documente bien su clase para que los clientes sepan cómo usarla. Esa es tu mejor apuesta.

Answer 3

Cuando se escribe que este es el uso típico:

debug() << "stuff" << "more stuff" << std::endl; 

está definitivamente planeando construir un objeto de depuración cada vez que lo utilice? Si es así, usted debe ser capaz de obtener el comportamiento que desea haciendo que el destructor de depuración añadir la nueva línea:

~debug() 
{ 
    *this << std::endl; 

    ... the rest of your destructor ... 
} 

Eso no significa que no puede hacer algo como esto:

// this won't output "line1" and "line2" on separate lines 
debug d; 
d << "line1"; 
d << "line2"; 

Answer 4

Algo como esto hacer:

struct debug { 
    debug() { 
    } 

    ~debug() { 
     std::cerr << m_SS.str() << std::endl; 
    } 

public: 
    // accepts just about anything 
    template<class T> 
    debug &operator<<(const T &x) { 
     m_SS << x; 
     return *this; 
    } 
private: 
    std::ostringstream m_SS; 
}; 

cual debería permitirle hacer cosas como esta:

debug() << "hello world"; 

He utilizado un patrón como este combinado con un bloqueo para proporcionar un sistema de registro como el flujo que puede garantizar que las entradas de registro se escriban atómicamente.

NOTA: código no probado, pero debería funcionar :-)