operator << - cómo detectar el último argumento

Question

Escribo una clase de registro en C++. Esta clase es un singleton. Quiero añadir registros de tal manera:

Log::GetInstance() << "Error: " << err_code << ", in class foo"; 

Ok, y dentro de un objeto de registro, quiero salvar toda esta línea en el momento en que el último argumento viene ("en la clase foo" en este ejemplo)

Cómo detectar el último < < argumento? < < a b < < < < is_this_last < < maybe_this_is < < or_not.

No uso ninguna etiqueta de cierre.

Answer 1

Puede resolver este problema si no utiliza un singleton. Si realiza una función como esta:

Log log() 
{ 
    return Log(); 
} 

se puede añadir un registro de casi la misma manera que lo hizo antes:

log() << "Error: " << err_code << ", in class foo"; 

La diferencia es que el destructor del objeto Log se llama después de esta línea . Entonces ahora tiene una forma de detectar cuándo se procesó el último argumento.

Answer 2

Me gustaría que tu Log::GetInstance devuelva un objeto proxy en lugar del propio objeto de registro. El objeto proxy guardará los datos que se escriben en él, y luego en su destructor, realmente escribirá los datos acumulados en el registro.

Answer 3

No se ponga demasiado listo con sus operadores. Debe sobrecargar a los operadores cuando tenga sentido hacerlo. Aquí no deberías. Eso se ve raro.

sólo debe tener un método estático que tiene este aspecto:

Log::Message(message_here); 

que toma un std :: string. Entonces los clientes tienen el dolor de cabeza de averiguar cómo armar la cadena de error.

Answer 4

Hace que Log devuelva un objeto diferente después del operador < <.

template<typename T> 
LogFindT operator<<(Log aLog, T const& data) 
{ 
    // Put stuff in log. 
    log.putStuffInLog(data); 

    // now return the object to detect the end of the statement. 
    return LogFindT(aLog); 
} 


struct LogFindT 
{ 
    LogFindT(Log& aLog) : TheLog(aLog) {} 
    Log& TheLog; 
    ~LogFindT() 
    { 
     // Do stuff when this object is eventually destroyed 
     // at the end of the expression. 
    } 
}; 

template<typename T> 
LogFindT& operator<<(LogFindT& aLog, T const& data) 
{ 
    aLog.TheLog.putStuffInLog(data); 

    // Return a reference to the input so we can chain. 
    // The object is thus not destroyed until the end of the stream. 
    return aLog; 
} 

Answer 5

creo que Jerry y Martin han dado la mejor sugerencia, pero en aras de la exhaustividad, lo primero que pensé fue std::endl.

Si implementado Log dentro del sistema iostream por una clase personalizada streambuf, a continuación, simplemente puede añadir << endl o << flush al final de la línea. Ya que estás preguntando, supongo que no lo hiciste.

Pero puede imitar la forma en que funciona endl.O bien agregar un controlador de manipulador

Log &operator<< (Log &l, Log & (*manip)(Log &)) 
    { return manip(l); } // generically call any manipulator 

Log &flog(Log &l) // define a manipulator "flush log" 
    { l->flush(); return l; } 

o añadir un dedicado operator<<

struct Flog {} flog; 

Log &operator<< (Log &l, Flog) 
    { l->flush(); return l; } 

Answer 6

No hay una buena manera de hacer lo que quiera. C y C++ simplemente no son lenguajes orientados a líneas. No hay una unidad más grande como una "línea de código" ni nada, ni se combinan las llamadas encadenadas de ninguna manera.

En C++, la expresión "un < < b < < c < < d" es exactamente equivalente a tres llamadas separadas a operador < <, así:

t1 = a; 
t2 = t1.operator<<(b); 
t3 = t2.operator<<(c); 
t4 = t3.operator<<(d); 

Por eso C++ ostreams uso endl como una marcador explícito de final de línea; simplemente no hay una forma decente de hacerlo de otra manera.