std::basic_string::append

 

C++

Lenguaje

Archivos de encabezado de la biblioteca estándar

Implementaciones independientes y albergadas

Requerimientos denominados

Biblioteca de soporte del lenguaje

Biblioteca de conceptos (C++20)

Biblioteca de diagnósticos

Biblioteca de utilerías

Biblioteca de cadenas

Biblioteca de contenedores

Biblioteca de iteradores

Biblioteca de rangos (C++20)

Biblioteca de algoritmos

Biblioteca numérica

Biblioteca de entrada/salida

Biblioteca de localizaciones

Biblioteca de expresiones regulares (C++11)

Biblioteca de operaciones atómicas (C++11)

Biblioteca de soporte de hilos (C++11)

Biblioteca de sistema de archivos (C++17)

Especificaciones técnicas

 

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)

 

	(1)
basic_string& append( size_type count, CharT ch );			(hasta C++20)
constexpr basic_string& append( size_type count, CharT ch );			(desde C++20)
		(2)
basic_string& append( const basic_string& str );				(hasta C++20)
constexpr basic_string& append( const basic_string& str );				(desde C++20)
			(3)
basic_string& append( const basic_string& str,                       size_type pos, size_type count );					(hasta C++14)
basic_string& append( const basic_string& str,                       size_type pos, size_type count = npos );					(desde C++14) (hasta C++20)
constexpr basic_string& append( const basic_string& str,                                 size_type pos, size_type count = npos );					(desde C++20)
				(4)
basic_string& append( const CharT* s, size_type count );						(hasta C++20)
constexpr basic_string& append( const CharT* s, size_type count );						(desde C++20)
					(5)
basic_string& append( const CharT* s );							(hasta C++20)
constexpr basic_string& append( const CharT* s );							(desde C++20)
						(6)
template< class InputIt > basic_string& append( InputIt first, InputIt last );								(hasta C++20)
template< class InputIt > constexpr basic_string& append( InputIt first, InputIt last );								(desde C++20)
							(7)
basic_string& append( std::initializer_list<CharT> ilist );									(desde C++11) (hasta C++20)
constexpr basic_string& append( std::initializer_list<CharT> ilist );									(desde C++20)
								(8)
template < class T > basic_string& append( const T& t );										(desde C++17) (hasta C++20)
template < class T > constexpr basic_string& append( const T& t );										(desde C++20)
									(9)
template < class T > basic_string& append( const T& t,                       size_type pos, size_type count = npos );											(desde C++17) (hasta C++20)
template < class T > constexpr basic_string& append( const T& t,                                 size_type pos, size_type count = npos );											(desde C++20)

Añade caracteres adicionales a la cadena.

1) Añade count copias del carácter ch.

2) Añade la cadena str.

3) Añade una subcadena [pos, pos+count) de str. Si la cadena solicitada se extiende más allá del final de la cadena, o si count == npos, la subcadena añadida es [pos, size()). Si pos > str.size(), se lanza std::out_of_range.

4) Añade los caracteres en el rango [s, s + count). Este rango puede contener caracteres nulos.

5) Añade la cadena de caracteres terminada en nulo a la que apunta s. La longitud de la cadena se determina por el primer carácter nulo usando Traits::length(s).

6) Añade los caracteres en el rango [first, last).

Esta sobrecarga tiene el mismo efecto que la sobrecarga (1) si InputIt es un tipo entero.	(hasta C++11)
Esta sobrecarga solo participa en la resolución de sobrecarga si InputIt califica como un LegacyInputIterator.	(desde C++11)

7) Añade caracteres de la lista de inicializadores ilist.

8) Implícitamente convierte t a una vista sobre cadena sv como si fuera mediante std::basic_string_view<CharT, Traits> sv = t;, entonces añade todos los caracteres de sv como si fuera mediante append(sv.data(), sv.size()) . Esta sobrecarga solo participa en la resolución de sobrecargas si std::is_convertible_v<const T&, std::basic_string_view<CharT, Traits>> es true y std::is_convertible_v<const T&, const CharT*> es false.

9) Implícitamente convierte t a una vista sobre cadena sv como si fuera mediante std::basic_string_view<CharT, Traits> sv = t;, entonces añade los caracteres de la subvista [pos, pos+count) de sv. Si la subvista solicitada se extiende más allá del final de sv, o si count == npos, la subvista añadida es [pos, sv.size()). Si pos >= sv.size(), se lanza std::out_of_range . Esta sobrecarga solo participa en la resolución de sobrecargas si std::is_convertible_v<const T&, std::basic_string_view<CharT, Traits>> es true y std::is_convertible_v<const T&, const CharT*> es false.

Parámetros

count	-	El número de caracteres a añadir.
pos	-	El índice del primer carácter a añadir.
ch	-	El valor del carácter a añadir.
first, last	-	El rango de caracteres a añadir.
str	-	La cadena a añadir.
s	-	Puntero a la cadena de caracteres a añadir.
ilist	-	Lista de inicializadores con los caracteres a añadir.
t	-	Objeto convertible a std::basic_string_view con los caracteres a añadir.

Valor de retorno

*this

Complejidad

No existen garantías estándar de complejidad. Las implementaciones típicas se comportan de manera similar a std::vector::insert.

Excepciones

Si por alguna razón se lanza una excepción, esta función no tiene efecto (garantía de excepción fuerte). (desde C++11)

Si la operación resultara en size() > max_size(), lanza std::length_error.

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
LWG 2946	C++17	La sobrecarga string_view ocasiona ambigüedad en algunos casos.	Se evitó haciéndola una plantilla.

Ejemplo

Ejecuta este código

#include <string>
#include <iostream>
 
int main() {
    std::basic_string<char> str = "string";
    const char* cptr = "C-string";
    const char carr[] = "Two and one";
 
    std::string output;
 
    // 1) Añade un char 3 veces. 
    // Fijarse, esta es la única sobrecarga que acepta chars.
    output.append(3, '*');
    std::cout << "1) " << output << "\n";
 
    //  2) Añade toda una cadena
    output.append(str);
    std::cout << "2) " << output << "\n";
 
    // 3) Añade parte de una cadena (las últimas 3 letras, en este caso)
    output.append(str, 3, 3);
    std::cout << "3) " << output << "\n";
 
    // 4) Añade parte de una cadena estilo C
    // Fijarse, ya que `append` devuelve *this, podemos encadenar las llamadas
    output.append(1, ' ').append(carr, 4);
    std::cout << "4) " << output << "\n";
 
    // 5) Añadir toda una cadena estilo C
    output.append(cptr);
    std::cout << "5) " << output << "\n";
 
    // 6) Añadir un rango
    output.append(&carr[3], std::end(carr));
    std::cout << "6) " << output << "\n";
 
    // 7) Añadir una lista de inicializadores
    output.append({ ' ', 'l', 'i', 's', 't' });
    std::cout << "7) " << output << "\n";
}

Salida:

1) ***
2) ***string
3) ***stringing
4) ***stringing Two 
5) ***stringing Two C-string
6) ***stringing Two C-string and one
7) ***stringing Two C-string and one list

Véase también

operator+=	Añade caracteres al final (función miembro pública)
strcat	Concatena dos cadenas (función)
strncat	Concatena una cierta cantidad de caracteres de dos cadenas (función)
wcscat	Anexa una copia de una cadena ancha a otra (función)
wcsncat	Anexa una cierta cantidad de caracteres anchos de una cadena ancha a otra (función)