¿Equivalente en C++ de StringBuffer / StringBuilder?

La forma de C++ sería usar std::stringstream o simplemente concatenaciones de cadenas simples. Las cadenas de C++ son mutables, por lo que las consideraciones de rendimiento de la concatenación son menos preocupantes.

Con respecto al formato, puede hacer todo el mismo formato en una secuencia, pero de una manera diferente, similar a cout. o puede usar un funtor fuertemente escrito que encapsula esto y proporciona una cadena.Formato como interfaz e. g. boost:: format

La cadena std::.la función append no es una buena opción porque no acepta muchas formas de datos. Una alternativa más útil es usar std: stringstream, así:

#include <sstream>
// ...

std::stringstream ss;

//put arbitrary formatted data into the stream
ss << 4.5 << ", " << 4 << " whatever";

//convert the stream buffer into a string
std::string str = ss.str();

std::string es el equivalente en C++: Es mutable.

Puede usar .append () para simplemente concatenar cadenas.

std::string s = "string1";
s.append("string2");

Creo que incluso podría ser capaz de hacer:

std::string s = "string1";
s += "string2";

En cuanto a las operaciones de formateo de C#'s StringBuilder, creo que snprintf (o sprintf si desea arriesgarse a escribir código con errores ;-) ) en una matriz de caracteres y convertir de nuevo a una cadena es aproximadamente la única opción.

Dado que std::string en C++ es mutable, puede usarlo. Tiene una función += operator y una append.

Si necesita añadir datos numéricos utilice las funciones std::to_string.

Si desea aún más flexibilidad en la forma de poder serializar cualquier objeto a una cadena, use la clase std::stringstream. Pero necesitarás implementar tus propias funciones de operador de streaming para que funcione con tus propias clases personalizadas.

Std:: string's += no funciona con const char* (lo que parecen ser cosas como "string to add"), así que definitivamente usar stringstream es lo más cercano a lo que se requiere - solo usa

El contenedor Rope puede valer la pena si tiene que insertar/eliminar cadena en el lugar aleatorio de la cadena de destino o para una larga secuencia de caracteres. Este es un ejemplo de la implementación de SGI:

crope r(1000000, 'x');          // crope is rope<char>. wrope is rope<wchar_t>
                                // Builds a rope containing a million 'x's.
                                // Takes much less than a MB, since the
                                // different pieces are shared.
crope r2 = r + "abc" + r;       // concatenation; takes on the order of 100s
                                // of machine instructions; fast
crope r3 = r2.substr(1000000, 3);       // yields "abc"; fast.
crope r4 = r2.substr(1000000, 1000000); // also fast.
reverse(r2.mutable_begin(), r2.mutable_end());
                                // correct, but slow; may take a
                                // minute or more.

Quería añadir algo nuevo por lo siguiente:

En un primer intento fallé en vencer

std::ostringstream 's operator<<

Eficiencia, pero con más intentos pude hacer un StringBuilder que es más rápido en algunos casos.

Cada vez que añado una cadena, simplemente almaceno una referencia a ella en algún lugar y aumento el contador del tamaño total.

La forma real en que finalmente lo implementé (Horror!) es utilizar un búfer opaco (std:: vector ):

• encabezado de 1 byte (2 bits para indicar si los siguientes datos son :cadena movida, cadena o byte [])
• 6 bits para decir la longitud del byte []

para byte [ ]

• Almaceno directamente bytes de cadenas cortas (para acceso a memoria secuencial)

para cadenas movidas (cadenas anexas con std::move)

• El puntero a un objeto std::string (tenemos propiedad)
• establecer una bandera en la clase si hay reservados no utilizados bytes there

para cadenas

• El puntero a un objeto std::string (sin propiedad)

También hay una pequeña optimización, si la última cadena insertada se movió, comprueba los bytes reservados pero no utilizados y almacena más bytes allí en lugar de usar el búfer opaco (esto es para ahorrar algo de memoria, en realidad lo hace un poco más lento, tal vez dependa también de la CPU, y es raro ver cadenas con espacio reservado adicional de todos modos)

Esto finalmente fue un poco más rápido que std::ostringstream pero tiene pocas desventajas:

• Asumí tipos de caracteres de longitud fija (así que 1,2 o 4 bytes, no es bueno para UTF8), no estoy diciendo que no funcionará para UTF8, Solo que no lo comprobé por pereza.
• Utilicé mala práctica de codificación (búfer opaco, fácil de hacer que no sea portátil, creo que el mío es portátil por cierto)
• Carece de todas las características de ostringstream
• Si se elimina alguna cadena referenciada antes de strings: comportamiento indefinido.

Conclusión? utilizar std::ostringstream

Ya soluciona el mayor cuello de botella mientras que ganar pocos puntos % de velocidad con la implementación de la mina no vale la pena las desventajas.

Un constructor de cadenas conveniente para c++

Como muchas personas respondieron antes, std::stringstream es el método de elección. Funciona bien y tiene muchas opciones de conversión y formato. IMO tiene un defecto bastante inconveniente sin embargo: No se puede utilizar como un trazador de líneas o como una expresión. Siempre tienes que escribir:

std::stringstream ss;
ss << "my data " << 42;
std::string myString( ss.str() );

Lo cual es bastante molesto, especialmente cuando desea inicializar cadenas en el constructor.

La razón es que a) std:: stringstream no tiene un operador de conversión a std::string y b) los operadores

La solución es anular std:: stringstream y darle mejores operadores coincidentes:

namespace NsStringBuilder {
template<typename T> class basic_stringstream : public std::basic_stringstream<T>
{
public:
    basic_stringstream() {}

    operator const std::basic_string<T> () const                                { return std::basic_stringstream<T>::str();                     }
    basic_stringstream<T>& operator<<   (bool _val)                             { std::basic_stringstream<T>::operator << (_val); return *this; }
    basic_stringstream<T>& operator<<   (char _val)                             { std::basic_stringstream<T>::operator << (_val); return *this; }
    basic_stringstream<T>& operator<<   (signed char _val)                      { std::basic_stringstream<T>::operator << (_val); return *this; }
    basic_stringstream<T>& operator<<   (unsigned char _val)                    { std::basic_stringstream<T>::operator << (_val); return *this; }
    basic_stringstream<T>& operator<<   (short _val)                            { std::basic_stringstream<T>::operator << (_val); return *this; }
    basic_stringstream<T>& operator<<   (unsigned short _val)                   { std::basic_stringstream<T>::operator << (_val); return *this; }
    basic_stringstream<T>& operator<<   (int _val)                              { std::basic_stringstream<T>::operator << (_val); return *this; }
    basic_stringstream<T>& operator<<   (unsigned int _val)                     { std::basic_stringstream<T>::operator << (_val); return *this; }
    basic_stringstream<T>& operator<<   (long _val)                             { std::basic_stringstream<T>::operator << (_val); return *this; }
    basic_stringstream<T>& operator<<   (unsigned long _val)                    { std::basic_stringstream<T>::operator << (_val); return *this; }
    basic_stringstream<T>& operator<<   (long long _val)                        { std::basic_stringstream<T>::operator << (_val); return *this; }
    basic_stringstream<T>& operator<<   (unsigned long long _val)               { std::basic_stringstream<T>::operator << (_val); return *this; }
    basic_stringstream<T>& operator<<   (float _val)                            { std::basic_stringstream<T>::operator << (_val); return *this; }
    basic_stringstream<T>& operator<<   (double _val)                           { std::basic_stringstream<T>::operator << (_val); return *this; }
    basic_stringstream<T>& operator<<   (long double _val)                      { std::basic_stringstream<T>::operator << (_val); return *this; }
    basic_stringstream<T>& operator<<   (void* _val)                            { std::basic_stringstream<T>::operator << (_val); return *this; }
    basic_stringstream<T>& operator<<   (std::streambuf* _val)                  { std::basic_stringstream<T>::operator << (_val); return *this; }
    basic_stringstream<T>& operator<<   (std::ostream& (*_val)(std::ostream&))  { std::basic_stringstream<T>::operator << (_val); return *this; }
    basic_stringstream<T>& operator<<   (std::ios& (*_val)(std::ios&))          { std::basic_stringstream<T>::operator << (_val); return *this; }
    basic_stringstream<T>& operator<<   (std::ios_base& (*_val)(std::ios_base&)){ std::basic_stringstream<T>::operator << (_val); return *this; }
    basic_stringstream<T>& operator<<   (const T* _val)                         { return static_cast<basic_stringstream<T>&>(std::operator << (*this,_val)); }
    basic_stringstream<T>& operator<<   (const std::basic_string<T>& _val)      { return static_cast<basic_stringstream<T>&>(std::operator << (*this,_val.c_str())); }
};

typedef basic_stringstream<char>        stringstream;
typedef basic_stringstream<wchar_t>     wstringstream;
}

Con esto, puedes escribir cosas como

std::string myString( NsStringBuilder::stringstream() << "my data " << 42 )

Incluso en el constructor.

Tengo que confesar que no medí el rendimiento, ya que tengo no se utiliza en un entorno que hace un uso intensivo de la construcción de cadenas todavía, pero supongo que no será mucho peor que std:: stringstream, ya que todo se hace a través de referencias (excepto la conversión a cadena, pero eso es una operación de copia en std::stringstream también)