stringstream problema ritorno ostream temporanea

Question

Sto creando un registratore con le seguenti sezioni:

// #define LOG(x) // for release mode 
#define LOG(x) log(x) 

log(const string& str); 
log(const ostream& str); 

Con l'idea di fare:

LOG("Test"); 
LOG(string("Testing") + " 123"); 
stringstream s; 
LOG(s << "Testing" << 1 << "two" << 3); 

Tutto questo funziona come previsto, ma quando lo faccio:

LOG(stringstream() << "Testing" << 1 << "two" << 3); 

non funziona:

void log(const ostream& os) 
{ 
    std::streambuf* buf = os.rdbuf(); 
    if(buf && typeid(*buf) == typeid(std::stringbuf)) 
    { 
    const std::string& format = dynamic_cast<std::stringbuf&>(*buf).str(); 
    cout << format << endl; 
    } 
} 

risultati in "formato" contenente dati indesiderati anziché la solita stringa corretta.

Penso che ciò sia dovuto al fatto che l'ostream temporaneo restituito dall'operatore < < sopravvive allo stringstream da cui proviene.

Oppure ho sbagliato?

(Perché la stringa() opera in questo modo? E 'perché restituisce un riferimento a se stesso? Sto assumendo di sì.)

Mi piacerebbe davvero farlo in questo modo, come vorrei essere eliminando il un'allocazione aggiuntiva quando si accede alla modalità di rilascio.

Qualsiasi suggerimento o trucchetto per farlo in questo modo sarebbe ben accetto. Nella mia attuale soluzione ho molte funzioni di registro diverse e sono tutte più complesse di così. Quindi preferirei che fosse implementato in qualche modo nel codice chiamante. (E non modificando il mio # define se possibile)

Tanto per dare un'idea, un esempio di uno dei miei # definisce effettivi:

#define LOG_DEBUG_MSG(format, ...) \ 
    LogMessage(DEBUG_TYPE, const char* filepos, sizeof(__QUOTE__(@__VA_ARGS__)), \ 
    format, __VA_ARGS__) 

che corrisponde varargs funzioni di log-printf come prendere char *, string() e ostream() così come le funzioni non vararg assumono string(), exception() e HRESULT.

Answer 1

I think Vedo cosa sta succedendo.Questo produce i risultati attesi:

log(std::stringstream() << 1 << "hello"); 

mentre questo non:

log(std::stringstream() << "hello" << 1); 

(scrive un numero esadecimale, seguita dalla cifra "1")

Alcuni elementi per la spiegazione :

• un rvalue non può essere associato a un riferimento non const
• E 'OK per richiamare le funzioni di membro a titolo temporaneo
• std :: ostream ha un operatore di membro < < (void *)
• std :: ostream ha un operatore di membro < < (int)
• Per char * l'operatore non è membro, è operatore di < < (std :: ostream &, const char *)

Nel codice precedente, std :: stringstream() crea un temporaneo (un rvalue). La sua durata non è problematica, in quanto deve durare per l'intera espressione completa in cui è dichiarata (vale a dire, finché non viene restituita la chiamata a log()).

Nel primo esempio, tutto funziona bene perché l'operatore membro < < (int) viene dapprima chiamato, e quindi il riferimento restituito può essere passato all'operatore < < (ostream &, const char *)

In il secondo esempio, operatore < < (non può essere chiamato con "std :: stringstream()" come primo argomento, poiché ciò richiederebbe che fosse associato a un riferimento non-const. Tuttavia, l'operatore membro < < (void *) è ok, dato che è un membro

A proposito: perché non definire la funzione log() come:

void log(const std::ostream& os) 
{ 
    std::cout << os.rdbuf() << std::endl; 
} 

Answer 2

alterare il vostro LOG() macro a questo:

#define LOG(x) do { std::stringstream s; s << x; log(s.str()); } while(0) 

che vi permetterà di utilizzare la seguente sintassi nei log di debug, quindi non c'è bisogno di costruire manualmente il flusso di stringa.

Quindi definirlo a zero per il rilascio e non avrai allocazioni aggiuntive.