c++ std::ostringstream vs std::string::append

En todos los ejemplos que usan algún tipo de almacenamiento en búfer, veo que usan flujo en lugar de cadena. ¿En qué se diferencian std::ostringstream y

Una diferencia que sé es que puede generar diferentes tipos en el flujo de salida (como un número entero) en lugar de los tipos limitados que acepta string::append.

Aquí hay un ejemplo:

std::ostringstream os;
os << "Content-Type: " << contentType << ";charset=" << charset << "\r\n";
std::string header = os.str();

contra

std::string header("Content-Type: ");
header.append(contentType);
header.append(";charset=");
header.append(charset);
header.append("\r\n");

Obviamente, usar stream es más corto, pero creo que append devuelve la referencia a la cadena para que pueda escribirse así:

std::string header("Content-Type: ");
header.append(contentType)
  .append(";charset=")
  .append(charset)
  .append("\r\n");

Y con el flujo de salida puedes hacer:

std::string content;
...
os << "Content-Length: " << content.length() << "\r\n";

Pero, ¿qué pasa con el uso de la memoria y la velocidad? Especialmente cuando se usa en un bucle grande.

Actualizar:

Para ser mas claro la pregunta es: ¿Cuál debo usar y por qué? ¿Hay situaciones en las que se prefiere uno u otro? Para el rendimiento y la memoria … bueno, creo que el punto de referencia es la única forma, ya que cada implementación podría ser diferente.

Actualización 2:

Bueno, no tengo una idea clara de qué debo usar de las respuestas, lo que significa que cualquiera de ellos hará el trabajo, más el vector. Cubbi Hizo un buen punto de referencia con la adición de Dietmar Kühl de que la mayor diferencia es la construcción de esos objetos. Si está buscando una respuesta, también debe verificarla. Esperaré un poco más por otras respuestas (busque la actualización anterior) y si no obtengo una, creo que aceptaré la respuesta de Tolga porque su sugerencia de usar el vector ya se hizo antes, lo que significa que el vector debería consumir menos recursos.

construyendo un objeto de flujo es una operación significativamente más compleja que la construcción de un objeto de cadena, porque tiene que contener (y, por lo tanto, construir) su std::locale miembro, entre otras cosas necesarias para mantener el estado (pero la configuración regional es, con mucho, la más pesada).

Agregar es similar: ambos mantienen una matriz contigua de caracteres, ambos asignan más cuando se excede la capacidad. Las únicas diferencias en las que puedo pensar es que cuando se agrega a una secuencia, hay una llamada de función de miembro virtual por desbordamiento (además de la asignación/copia de memoria, que domina el manejo de desbordamiento de todos modos), y operator<< tiene que hacer algunas comprobaciones adicionales del estado de la transmisión.

Además, tenga en cuenta que está llamando a str(), que copia la cadena completa una vez más, por lo que, según lo que su código está escrito para hacer, el ejemplo de flujo hace más y debería ser más lento.

Probemos:

#include <sstream>
#include <string>
#include <numeric>

volatile unsigned int sink;
std::string contentType(50, ' ');
std::string charset(50, ' ');
int main()
{
 for(long n = 0; n < 10000000; ++n)
 {
#ifdef TEST_STREAM    
    std::ostringstream os;
    os << "Content-Type: " << contentType << ";charset=" << charset << "\r\n";
    std::string header = os.str();
#endif
#ifdef TEST_STRING
    std::string header("Content-Type: ");
    header.append(contentType);
    header.append(";charset=");
    header.append(charset);
    header.append("\r\n");
#endif
    sink += std::accumulate(header.begin(), header.end(), 0);
 }
}

ese es 10 millones repeticiones

En mi Linux, obtengo

                   stream         string
g++ 4.8          7.9 seconds      4.4 seconds
clang++/libc++  11.3 seconds      3.3 seconds

entonces, para este caso de uso, en estas dos implementaciones, las cadenas parecen funcionar más rápido, pero obviamente ambas formas tienen mucho que mejorar (reservar () la cadena, mover la construcción del flujo fuera del ciclo, usar un flujo que no requiere copiar para acceder a su búfer, etc.)

std::ostringstream no se almacena necesariamente como una matriz secuencial de caracteres en la memoria. En realidad, necesitaría tener una matriz continua de caracteres al enviar esos encabezados HTTP y eso podría copiar/modificar el búfer interno para que sea secuencial.

std::string usando apropiado std::string::reserve no tiene ninguna razón para actuar más lento que std::ostringstream en esta situación.

Sin embargo, std::ostringstream es probablemente más rápido para agregar si no tiene idea del tamaño que tiene que reservar. Si utiliza std::string y su cadena crece, eventualmente requiere reasignación y copia de todo el búfer. seria mejor usar uno std::ostringstream::str() para hacer que los datos sean secuenciales a la vez en comparación con las reasignaciones múltiples que ocurrirían de otra manera.

PS Pre-C++11 std::string tampoco se requiere que sea secuencial, mientras que casi todas las bibliotecas lo implementan como secuencial. Podrías arriesgarte o usar std::vector<char> en cambio. Necesitaría usar lo siguiente para agregar:

char str[] = ";charset=";
vector.insert(vector.end(), str, str + sizeof(str) - 1);

std::vector<char> Sería mejor para el rendimiento porque probablemente sea más barato de construir, pero probablemente no sea de importancia en comparación con std::string y el tiempo real que tardan en construirse. Hice algo similar a lo que estás intentando y fui con std::vector<char> antes de. Puramente por razones lógicas; vector parecía ajustarse mejor al trabajo. En realidad, no desea manipulaciones de cadenas o algo así. Además, los puntos de referencia que hice más tarde demostraron que funcionaba mejor o tal vez fue solo porque no implementé las operaciones lo suficientemente bien con std::string.

Al elegir, el contenedor que tiene requisitos para sus necesidades y características adicionales mínimas generalmente hace el mejor trabajo.

Con stream puedes tener tu clase Myclass anular el << operación para que puedas escribir

MyClass x;
ostringstream y;
y << x;

Para agregar, debe tener un método ToString (o algo similar), ya que no puede anular la función de agregar cadena.

Para algunas piezas de código, use lo que le resulte más cómodo. Use stream para proyectos más grandes donde es útil poder simplemente transmitir un objeto.

Si le preocupa la velocidad, debe perfilar y/o probar. En teoria std::string::append no debe ser más lento, ya que es más simple (la transmisión tiene que lidiar con la configuración regional, el formato diferente y ser más genérica). Pero cuán rápida es realmente una solución u otra solo puede darse cuenta mediante la prueba.