stringstream temporal para c_str() en una sola declaración

Question

considera la siguiente función:

void f(const char* str); 

Supongamos que quiero generar una cadena usando stringstream y pasarlo a esta función. Si quiero hacerlo en un comunicado, probaría:

f((std::ostringstream() << "Value: " << 5).str().c_str()); // error 

Esto da un error: 'str()' no es un miembro de 'basic_ostream'. OK, entonces el operador < < está regresando ostream en lugar de ostringstream - ¿qué hay de devolverlo a un ostringstream?

1) ¿Es seguro este yeso?

f(static_cast<std::ostringstream&>(std::ostringstream() << "Value: " << 5).str().c_str()); // incorrect output 

Ahora con esto, resulta que para el < < ("Valor:") operador de llamada, en realidad está llamando operador de ostream < < (void *) e imprimir una dirección hexadecimal. Esto está mal, quiero el texto.

2) ¿Por qué el operador < < en el std :: ostringstream() temporal llama al operador ostream? Sin duda, el temporal tiene un tipo de 'ostringstream' no 'ostream'?

¡Puedo lanzar el temporal para forzar la llamada correcta del operador también!

f(static_cast<std::ostringstream&>(static_cast<std::ostringstream&>(std::ostringstream()) << "Value: " << 5).str().c_str()); 

Esto parece trabajar y pasa "Valor: 5" para f().

3) ¿Confío en un comportamiento indefinido ahora? Los moldes parecen inusuales.

---

yo sepa la mejor alternativa es algo como esto:

std::ostringstream ss; 
ss << "Value: " << 5; 
f(ss.str().c_str()); 

... pero estoy interesado en el comportamiento de hacerlo en una sola línea. Supongamos que alguien quisiera crear una macro (dudosa):

#define make_temporary_cstr(x) (static_cast<std::ostringstream&>(static_cast<std::ostringstream&>(std::ostringstream()) << x).str().c_str()) 

// ... 

f(make_temporary_cstr("Value: " << 5)); 

¿Funcionaría como se esperaba?

Answer 1

No puede convertir la secuencia temporal a std::ostringstream&. Está mal formado (el compilador debe decirle que está mal). Lo siguiente puede hacerlo, sin embargo:

f(static_cast<std::ostringstream&>(
    std::ostringstream().seekp(0) << "Value: " << 5).str().c_str()); 

Eso por supuesto es feo. Pero muestra cómo puede funcionar. seekp es una función miembro que devuelve un std::ostream&.Probablemente mejor escribir esto generalmente

template<typename T> 
struct lval { T t; T &getlval() { return t; } }; 

f(static_cast<std::ostringstream&>(
    lval<std::ostringstream>().getlval() << "Value: " << 5).str().c_str()); 

La razón de que sin nada que tarda el void*, se debe a que operator<< es una función miembro. El operator<< que toma un char const* no lo es.

Answer 2

Un temporal no se puede pasar como una referencia no constante a una función, es por eso que no encuentra el operador de transmisión correcto y toma el que tiene el argumento void * (es una función miembro y lo llama en un temporal está bien).

Lo que se refiere a superar las limitaciones por el casting, tengo la sensación de que es, de hecho, UB, pero no puedo decirlo con certeza. Alguien más seguramente citará el estándar.

Answer 3

Si te gusta declaraciones one_lined puede escribir:

// void f(const char* str); 
f(static_cast<ostringstream*>(&(ostringstream() << "Value: " << 5))->str()); 

Sin embargo, usted debe preferir más fácil de mantener código como:

template <typename V> 
    string NumberValue(V val) 
    { 
    ostringstream ss; 
    ss << "Value: " << val; 
    return ss.str(); 
    } 
f(NumberValue(5)); 

Answer 4

utilizo algo un poco como esta para el registro.

#include <sstream> 

using namespace std; 

const char *log_text(ostringstream &os, ostream &theSame) 
{ 
    static string ret; // Static so it persists after the call 
    ret = os.str(); 
    os.str(""); // Truncate so I can re-use the stream 
    return ret.c_str(); 
} 


int main(int argc, char **argv) 
{ 
    ostringstream ss; 
    cout << log_text(ss, ss << "My first message") << endl; 
    cout << log_text(ss, ss << "Another message") << endl; 
} 

Salida:

Mi primer mensaje

Otro mensaje

Answer 5

Esto se puede hacer usando una función lambda C++ 11.

#include <iostream> 
#include <sstream> 

void f(const char * str) 
{ 
    std::cout << str << std::endl; 
} 

std::string str(void (*populate)(std::ostream &)) 
{ 
    std::ostringstream stream; 
    populate(stream); 
    return stream.str(); 
} 

int main(int argc, char * * args) 
{ 
    f(str([](std::ostream & ss){ ss << "Value: " << 5; }).c_str()); 
    return 0; 
} 

// g++ -std=c++11 main.cpp -o main 
// ./main 
// Value: 5