std::operator+(std::basic_string) - cppreference.com

Definido en el archivo de encabezado `<string>`
`template< class CharT, class Traits, class Alloc > std::basic_string<CharT,Traits,Alloc> operator+( const std::basic_string<CharT,Traits,Alloc>& lhs, const std::basic_string<CharT,Traits,Alloc>& rhs );`	(1)	(constexpr since C++20)
`template< class CharT, class Traits, class Alloc > std::basic_string<CharT,Traits,Alloc> operator+( const std::basic_string<CharT,Traits,Alloc>& lhs, const CharT* rhs );`	(2)	(constexpr since C++20)
`template<class CharT, class Traits, class Alloc> std::basic_string<CharT,Traits,Alloc> operator+( const std::basic_string<CharT,Traits,Alloc>& lhs, CharT rhs );`	(3)	(constexpr since C++20)
`template< class CharT, class Traits, class Alloc > std::basic_string<CharT,Traits,Alloc> operator+( const CharT* lhs, const std::basic_string<CharT,Traits,Alloc>& rhs );`	(4)	(constexpr since C++20)
`template< class CharT, class Traits, class Alloc > std::basic_string<CharT,Traits,Alloc> operator+( CharT lhs, const std::basic_string<CharT,Traits,Alloc>& rhs );`	(5)	(constexpr since C++20)
`template< class CharT, class Traits, class Alloc > std::basic_string<CharT,Traits,Alloc> operator+( std::basic_string<CharT,Traits,Alloc>&& lhs, std::basic_string<CharT,Traits,Alloc>&& rhs );`	(6)	(desde C++11) (constexpr since C++20)
`template< class CharT, class Traits, class Alloc > std::basic_string<CharT,Traits,Alloc> operator+( std::basic_string<CharT,Traits,Alloc>&& lhs, const std::basic_string<CharT,Traits,Alloc>& rhs );`	(7)	(desde C++11) (constexpr since C++20)
`template< class CharT, class Traits, class Alloc > std::basic_string<CharT,Traits,Alloc> operator+( std::basic_string<CharT,Traits,Alloc>&& lhs, const CharT* rhs );`	(8)	(desde C++11) (constexpr since C++20)
`template< class CharT, class Traits, class Alloc > std::basic_string<CharT,Traits,Alloc> operator+( std::basic_string<CharT,Traits,Alloc>&& lhs, CharT rhs );`	(9)	(desde C++11) (constexpr since C++20)
`template< class CharT, class Traits, class Alloc > std::basic_string<CharT,Traits,Alloc> operator+( const std::basic_string<CharT,Traits,Alloc>& lhs, std::basic_string<CharT,Traits,Alloc>&& rhs );`	(10)	(desde C++11) (constexpr since C++20)
`template< class CharT, class Traits, class Alloc > std::basic_string<CharT,Traits,Alloc> operator+( const CharT* lhs, std::basic_string<CharT,Traits,Alloc>&& rhs );`	(11)	(desde C++11) (constexpr since C++20)
`template< class CharT, class Traits, class Alloc > std::basic_string<CharT,Traits,Alloc> operator+( CharT lhs, std::basic_string<CharT,Traits,Alloc>&& rhs );`	(12)	(desde C++11) (constexpr since C++20)

Devuelve una cadena que contiene caracteres de lhs seguido de caracteres de rhs.

El asignador de memoria usado para el resutlado es:

1-3) std::allocator_traits<Alloc>::select_on_container_copy_construction(lhs.get_allocator())

4-5) std::allocator_traits<Alloc>::select_on_container_copy_construction(rhs.get_allocator())

6-9) lhs.get_allocator()

10-12) rhs.get_allocator()

En otras palabras, si un operando es un rvalue basic_string, se usa su asignador. De lo contrario, se usa select_on_container_copy_construction en el asignador del operando lvalue basic_string. En cada caso, se prefiere el operando izquierdo cuando ambos son tipo basic_string de la misma categoría de valor.

Para (6-12), todos los operandos rvalue basic_string se dejan en un estado válido pero sin especificar.

(desde C++11)

Parámetros

lhs	-	Cadena, carácter o puntero al primer carácter en una array terminado en nulo.
rhs	-	Cadena, carácter o puntero al primer carácter en una array terminado en nulo.

Valor de retorno

Una cadena que contiene los caracteres de lhs seguido de los caracteres de rhs, usando el asignador de memoria determinado anteriormente (desde C++11).

Notas

Deberá usarse el operador operator+ con precaución cuando se involucren asignadores con estado (como cuando se use std::pmr::string) (desde C++17). Antes de P1165R1, el asignador usado para el resultado se determinaba por un accidente histórico y puede variar de sobrecarga a sobrecarga sin una razón aparente. Aún más, para (1-5), la propagación del comportamiento del asignador varía entre las implementaciones más importantes de la biblioteca estándar y difiere del comportamiento representado en el estándar.

Ya que el asignador usado por el resultado de operator+ es susceptible a la categoría de valor, operator+ no es asociativo con respecto a la propagación del asignador:

using mi_cadena = std::basic_string<char, std::char_traits<char>, mi_asignador<char>>;
mi_cadena gato();
const mi_cadena& perro();

mi_cadena miau = /* ... */, guau = /* ... */;
miau + gato() + /*...*/;  // usa SOCCC en el asignador de miau
guau + perro() + /*...*/; // en su lugar, usa el asignador del valor de retorno de perro()

miau + guau + miau;   // usa SOCCC en el asignador de miau
miau + (guau + miau); // en su lugar usa SOCCC en el asignador de guau

Para una cadena de invocaciones de operator+, el asignador usado para el resultado final puede controlarse anteponiendo un rvalue basic_string con el asignador deseado:

// usar mi_asignador_favorito para el resultado final
mi_cadena(mi_asignador_favorito) + miau + guau + gato() + perro();

Para un mejor y portable control sobre asignadores, las funciones miembro como append(), insert(), y operator+=() deberán usarse en una cadena resultado construida con el asignador deseado.

(desde C++11)

Ejemplo

#include <iostream>
#include <string>

int main()
{
    std::string s1 = "Hola";
    std::string s2 = "mundo";
    std::cout << s1 + ' ' + s2 + "!\n";
}

Salida:

Informes de defectos

Los siguientes informes de defectos de cambio de comportamiento se aplicaron de manera retroactiva a los estándares de C++ publicados anteriormente.