Escuché a algunas personas expresar preocupaciones sobre el operador "+" en std :: string y varias soluciones para acelerar la concatenación. ¿Alguno de estos es realmente necesario? Si es así, ¿cuál es la mejor manera de concatenar cadenas en C ++?

El trabajo adicional probablemente no valga la pena, a menos que realmente necesite eficiencia. Probablemente tendrá una eficiencia mucho mejor simplemente usando el operador + = en su lugar.

Ahora, después de ese descargo de responsabilidad, responderé a su pregunta real ...

La eficiencia de la clase de cadena STL depende de la implementación de STL que esté utilizando.

Puede garantizar la eficiencia y tener un mayor control si realiza la concatenación manualmente mediante las funciones integradas de c.

Por qué operator + no es eficiente:

Eche un vistazo a esta interfaz:

template <class charT, class traits, class Alloc>
basic_string<charT, traits, Alloc>
operator+(const basic_string<charT, traits, Alloc>& s1,
          const basic_string<charT, traits, Alloc>& s2)

Puede ver que se devuelve un nuevo objeto después de cada +. Eso significa que se utiliza un búfer nuevo cada vez. Si está haciendo un montón de operaciones adicionales, no es eficiente.

Por qué puede hacerlo más eficiente:

• Estás garantizando eficiencia en lugar de confiar en que un delegado lo haga de manera eficiente por ti
• la clase std :: string no sabe nada sobre el tamaño máximo de su cadena, ni la frecuencia con la que la concatena. Es posible que tenga este conocimiento y pueda hacer cosas basándose en tener esta información. Esto dará lugar a menos reasignaciones.
• Controlará los búferes manualmente para asegurarse de que no copiará toda la cadena en búferes nuevos cuando no desee que eso suceda.
• Puede usar la pila para sus búferes en lugar del montón, que es mucho más eficiente.
• string + operator creará un nuevo objeto de cadena y lo devolverá usando un nuevo búfer.

Consideraciones para la implementación:

• Mantenga un registro de la longitud de la cuerda.
• Mantenga un puntero al final de la cadena y al inicio, o solo al inicio y use el inicio + la longitud como un desplazamiento para encontrar el final de la cadena.
• Asegúrese de que el búfer en el que está almacenando su cadena sea lo suficientemente grande para que no necesite reasignar datos
• Use strcpy en lugar de strcat para que no necesite iterar sobre la longitud de la cadena para encontrar el final de la cadena.

Estructura de datos de la cuerda:

Si necesita concatenaciones realmente rápidas, considere usar una estructura de datos de cuerdas .

Reserve su espacio final antes, luego use el método de adición con un búfer. Por ejemplo, supongamos que espera que la longitud de la cadena final sea de 1 millón de caracteres:

std::string s;
s.reserve(1000000);

while (whatever)
{
  s.append(buf,len);
}

Yo no me preocuparía por eso. Si lo hace en un bucle, las cadenas siempre preasignarán memoria para minimizar las reasignaciones; solo úselas operator+=en ese caso. Y si lo haces manualmente, algo como esto o más

a + " : " + c

Luego está creando temporales, incluso si el compilador pudiera eliminar algunas copias del valor de retorno. Esto se debe a que en un llamado sucesivamente operator+no se sabe si el parámetro de referencia hace referencia a un objeto con nombre o un retorno temporal de una operator+subinvocación. Preferiría no preocuparme por eso antes de no haber perfilado primero. Pero tomemos un ejemplo para demostrarlo. Primero introducimos paréntesis para aclarar el enlace. Pongo los argumentos directamente después de la declaración de función que se usa para mayor claridad. Debajo de eso, muestro cuál es la expresión resultante:

((a + " : ") + c) 
calls string operator+(string const&, char const*)(a, " : ")
  => (tmp1 + c)

Ahora, en esa adición, tmp1 es lo que devolvió la primera llamada al operador + con los argumentos mostrados. Suponemos que el compilador es realmente inteligente y optimiza la copia del valor de retorno. Así que terminamos con una nueva cadena que contiene la concatenación de ay " : ". Ahora, esto sucede:

(tmp1 + c)
calls string operator+(string const&, string const&)(tmp1, c)
  => tmp2 == <end result>

Compare eso con lo siguiente:

std::string f = "hello";
(f + c)
calls string operator+(string const&, string const&)(f, c)
  => tmp1 == <end result>

¡Está usando la misma función para una cadena temporal y para una cadena con nombre! Entonces el compilador tiene que copiar el argumento en una nueva cadena y agregarlo y devolverlo desde el cuerpo de operator+. No puede tomar la memoria de un temporal y agregarlo. Cuanto más grande sea la expresión, más copias de cadenas deberán realizarse.

Siguiente Visual Studio y GCC admitirán la semántica de movimiento de c ++ 1x (complementando la semántica de copia ) y las referencias rvalue como una adición experimental. Eso permite averiguar si el parámetro hace referencia a un temporal o no. Esto hará que las adiciones sean increíblemente rápidas, ya que todo lo anterior terminará en una "tubería de adición" sin copias.

Si resulta ser un cuello de botella, aún puede hacerlo

 std::string(a).append(" : ").append(c) ...

Las appendllamadas añaden el argumento ay *thisluego devuelven una referencia a sí mismas. Por lo tanto, no se realiza ninguna copia de temporales allí. O alternativamente, operator+=se puede usar, pero necesitaría paréntesis feos para arreglar la precedencia.

Para la mayoría de las aplicaciones, simplemente no importa. Simplemente escriba su código, felizmente inconsciente de cómo funciona exactamente el operador +, y solo tome el asunto en sus propias manos si se convierte en un cuello de botella aparente.

A diferencia de .NET System.Strings, std :: strings de C ++ son mutables y, por lo tanto, se pueden construir mediante una simple concatenación tan rápido como con otros métodos.

¿quizás std :: stringstream en su lugar?

Pero estoy de acuerdo con la opinión de que probablemente debería mantenerlo mantenible y comprensible y luego perfilarlo para ver si realmente está teniendo problemas.

En Imperfect C ++ , Matthew Wilson presenta un concatenador dinámico de cadenas que calcula previamente la longitud de la cadena final para tener solo una asignación antes de concatenar todas las partes. También podemos implementar un concatenador estático jugando con plantillas de expresión .

Ese tipo de idea se ha implementado en la implementación de STLport std :: string, que no se ajusta al estándar debido a este truco preciso.

std::string operator+asigna una nueva cadena y copia las dos cadenas de operandos cada vez. repite muchas veces y se vuelve caro, O (n).

std::string appendy, operator+=por otro lado, aumente la capacidad en un 50% cada vez que la cuerda necesite crecer. Lo que reduce significativamente el número de asignaciones de memoria y operaciones de copia, O (log n).

Para cuerdas pequeñas, no importa. Si tiene cadenas grandes, será mejor que las almacene como están en vector o en alguna otra colección como partes. Y adapte su algoritmo para trabajar con ese conjunto de datos en lugar de una cadena grande.

Prefiero std :: ostringstream para la concatenación compleja.

Como ocurre con la mayoría de las cosas, es más fácil no hacer algo que hacerlo.

Si desea generar cadenas grandes en una GUI, puede ser que lo que sea que esté generando pueda manejar las cadenas en partes mejor que como una cadena grande (por ejemplo, concatenando texto en un editor de texto; por lo general, mantienen las líneas separadas estructuras).

Si desea exportar a un archivo, transmita los datos en lugar de crear una cadena grande y generarla.

Nunca he encontrado la necesidad de hacer que la concatenación sea más rápida si eliminé la concatenación innecesaria del código lento.

Probablemente el mejor rendimiento si preasigna (reserva) espacio en la cadena resultante.

template<typename... Args>
std::string concat(Args const&... args)
{
    size_t len = 0;
    for (auto s : {args...})  len += strlen(s);

    std::string result;
    result.reserve(len);    // <--- preallocate result
    for (auto s : {args...})  result += s;
    return result;
}

Uso:

std::string merged = concat("This ", "is ", "a ", "test!");

Una matriz simple de caracteres, encapsulada en una clase que realiza un seguimiento del tamaño de la matriz y el número de bytes asignados es la más rápida.

El truco consiste en hacer solo una gran asignación al principio.

a

https://github.com/pedro-vicente/table-string

Benchmarks

Para Visual Studio 2015, compilación de depuración x86, mejora sustancial sobre C ++ std :: string.

| API                   | Seconds           
| ----------------------|----| 
| SDS                   | 19 |  
| std::string           | 11 |  
| std::string (reserve) | 9  |  
| table_str_t           | 1  |  

Puede probar este con reservas de memoria para cada elemento:

namespace {
template<class C>
constexpr auto size(const C& c) -> decltype(c.size()) {
  return static_cast<std::size_t>(c.size());
}

constexpr std::size_t size(const char* string) {
  std::size_t size = 0;
  while (*(string + size) != '\0') {
    ++size;
  }
  return size;
}

template<class T, std::size_t N>
constexpr std::size_t size(const T (&)[N]) noexcept {
  return N;
}
}

template<typename... Args>
std::string concatStrings(Args&&... args) {
  auto s = (size(args) + ...);
  std::string result;
  result.reserve(s);
  return (result.append(std::forward<Args>(args)), ...);
}