Espacios de nombres
Variantes
    Acciones
       
      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
       
      std::basic_string
       
      </tbody> <tbody class="t-dcl-rev t-dcl-rev-num "> </tbody><tbody> </tbody> <tbody class="t-dcl-rev t-dcl-rev-num "> </tbody><tbody> </tbody> <tbody class="t-dcl-rev t-dcl-rev-num "> </tbody><tbody> </tbody> <tbody class="t-dcl-rev t-dcl-rev-num "> </tbody><tbody> </tbody> <tbody class="t-dcl-rev t-dcl-rev-num "> </tbody><tbody> </tbody> <tbody class="t-dcl-rev t-dcl-rev-num "> </tbody><tbody> </tbody> <tbody class="t-dcl-rev t-dcl-rev-num "> </tbody><tbody> </tbody> <tbody class="t-dcl-rev t-dcl-rev-num "> </tbody><tbody> </tbody> <tbody class="t-dcl-rev t-dcl-rev-num "> </tbody><tbody>
      (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 InputIterator.

      		(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

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