std::operator+(std::basic_string)

 

C++

Apoyo de compiladores

Implementaciones independientes y albergadas

Lenguaje

Biblioteca estándar

Encabezados de la biblioteca estándar

Requisitos denominados

Macros de prueba de característica (C++20)

Biblioteca de apoyo del lenguaje

Biblioteca de conceptos(C++20)

Biblioteca de diagnósticos

Biblioteca de gestión de memoria

Biblioteca de metaprogramación(C++11)

Biblioteca de servicios generales

Biblioteca de contenedores

Biblioteca de iteradores

Biblioteca de rangos(C++20)

Biblioteca de algoritmos

Biblioteca de cadenas

Biblioteca de procesamiento de texto

Biblioteca numérica

Biblioteca de fecha y hora

Biblioteca de entrada/salida

Biblioteca del sistema de archivos(C++17)

Biblioteca de apoyo de concurrencia(C++11)

Biblioteca de apoyo de ejecución(C++26)

Especificaciones técnicas

Índice de símbolos

Bibliotecas externas

 

Biblioteca de cadenas

Cadenas terminadas en nulo

Cadenas de bytes

Cadenas multibyte

De caracteres anchos

Clases

basic_string

basic_string_view (C++17)

char_traits

 

std::basic_string

Funciones miembro basic_string::basic_string basic_string::operator= basic_string::assign basic_string::get_allocator Acceso a elementos basic_string::at basic_string::operator[] basic_string::front (C++11) basic_string::back (C++11) basic_string::data basic_string::c_str basic_string::operator basic_string_view (C++17) Iteradores basic_string::beginbasic_string::cbegin (C++11) basic_string::endbasic_string::cend (C++11) basic_string::rbeginbasic_string::crbegin (C++11) basic_string::rendbasic_string::crend (C++11) Capacidad basic_string::empty basic_string::sizebasic_string::length basic_string::max_size basic_string::reserve basic_string::capacity basic_string::shrink_to_fit (C++11)

Operaciones basic_string::clear basic_string::insert basic_string::erase basic_string::push_back basic_string::pop_back (C++11) basic_string::append basic_string::operator+= basic_string::compare basic_string::starts_with (C++20) basic_string::ends_with (C++20) basic_string::replace basic_string::substr basic_string::copy basic_string::resize basic_string::swap Búsqueda basic_string::find basic_string::rfind basic_string::find_first_of basic_string::find_first_not_of basic_string::find_last_of basic_string::find_last_not_of Constantes basic_string::npos

Funciones no miembro operator+ swap(std::basic_string) operator""s (C++14) erase(std::basic_string)erase_if(std::basic_string) (C++20)(C++20) E/S operator<<operator>> getline Comparación operator==operator!=operator<operator>operator<=operator>=operator<=> (hasta C++20)(hasta C++20)(hasta C++20)(hasta C++20)(hasta C++20)(C++20) Conversión numérica (C++11) stoistolstoll stoulstoull stofstodstold to_string to_wstring Clases auxiliares hash<std::string>hash<std::wstring>hash<std::u32string>hash<std::u16string>hash<std::u8string> (C++11)(C++11)(C++11)(C++11)(C++20) hash<std::pmr::string>hash<std::pmr::wstring>hash<std::pmr::u32string>hash<std::pmr::u16string>hash<std::pmr::u8string> (C++20)(C++20)(C++20)(C++20)(C++20) Guías de deducción(C++17)

 

Definido en el archivo de encabezado <string>
template<class CharT, class Traits, class Alloc >     std::basic_string<CharT,Traits,Alloc>         operator+(conststd::basic_string<CharT,Traits,Alloc>& lhs,                    conststd::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+(conststd::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+(conststd::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,                    conststd::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,                    conststd::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,                    conststd::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+(conststd::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

Ejecuta este código

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

Salida:

Hola mundo!

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.

ID	Aplicado a	Comportamiento según lo publicado	Comportamiento correcto
P1165R1	C++11	La propagación del asignador es aleatoria e inconsistente.	Se hizo más consistente.

Véase también

operator+=	Añade caracteres al final (función miembro pública)
append	Añade caracteres al final (función miembro pública)
insert	Inserta caracteres (función miembro pública)