std::basic_string::insert

 

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)

 

(1)

basic_string& insert( size_type index, size_type count, CharT ch );

(hasta C++20)

constexpr basic_string& insert( size_type index, size_type count, CharT ch );

(desde C++20)

(2)

basic_string& insert( size_type index, const CharT* s );

(hasta C++20)

constexpr basic_string& insert( size_type index, const CharT* s );

(desde C++20)

(3)

basic_string& insert( size_type index, const CharT* s, size_type count );

(hasta C++20)

constexpr basic_string& insert( size_type index,                                 const CharT* s, size_type count );

(desde C++20)

(4)

basic_string& insert( size_type index, const basic_string& str );

(hasta C++20)

constexpr basic_string& insert( size_type index, const basic_string& str );

(desde C++20)

(5)

basic_string& insert( size_type index, const basic_string& str,                       size_type index_str, size_type count );

(hasta C++14)

basic_string& insert( size_type index, const basic_string& str,                       size_type index_str, size_type count = npos);

(desde C++14) (hasta C++20)

constexpr basic_string& insert( size_type index, const basic_string& str,                                 size_type index_str, size_type count = npos);

(desde C++20)

(6)

iterator insert( iterator pos, CharT ch );

(hasta C++11)

iterator insert( const_iterator pos, CharT ch );

(desde C++11) (hasta C++20)

constexpr iterator insert( const_iterator pos, CharT ch );

(desde C++20)

(7)

void insert( iterator pos, size_type count, CharT ch );

(hasta C++11)

iterator insert( const_iterator pos, size_type count, CharT ch );

(desde C++11) (hasta C++20)

constexpr iterator insert( const_iterator pos, size_type count, CharT ch );

(desde C++20)

(8)

template<class InputIt > void insert( iterator pos, InputIt first, InputIt last );

(hasta C++11)

template<class InputIt > iterator insert( const_iterator pos, InputIt first, InputIt last );

(desde C++11) (hasta C++20)

template<class InputIt > constexpr iterator insert( const_iterator pos, InputIt first, InputIt last );

(desde C++20)

(9)

iterator insert( const_iterator pos, std::initializer_list<CharT> ilist );

(desde C++11) (hasta C++20)

constexpr iterator insert( const_iterator pos,                            std::initializer_list<CharT> ilist );

(desde C++20)

(10)

template<class T > basic_string& insert( size_type pos, const T& t );

(desde C++17) (hasta C++20)

template<class T > constexpr basic_string& insert( size_type pos, const T& t );

(desde C++20)

(11)

template<class T > basic_string& insert( size_type index, const T& t,                       size_type index_str, size_type count = npos);

(desde C++17) (hasta C++20)

template<class T > constexpr basic_string& insert( size_type index, const T& t,                                 size_type index_str, size_type count = npos);

(desde C++20)

Inserta caracteres en la cadena.

1) Inserta count copias del carácter ch en la posición index

2) Inserta la cadena de caracteres terminada en nulo a la que apunta s en la posición index. La longitud de la cadena se determina por el primer carácter nulo usando Traits::length(s).

3) Inserta los caracteres en el rango [s, s+count) en la posición index. El rango puede contener caracteres nulos.

4) Inserta la cadena str en la posición index.

5) Inserta una cadena, obtenida mediante str.substr(index_str, count) en la posición index.

6) Inserta el carácter ch antes del carácter al que apunta pos.

7) Inserta count copias del carácter ch antes del elemento (si es que lo hay) al que apunta pos

8) Inserta caracteres del rango [first, last) antes del elemento (si es que lo hay) al que apunta pos. Esta sobrecarga no participa en la resolución de sobrecarga si InputIt no satisface a InputIterator.(desde C++11)

9) Inserta los elementos de la lista de inicializadores ilist antes del elemento (si es que lo hay) al que apunta pos

10) Implícitamente convierte t a una vista sobre cadena sv como si fuera mediante std::basic_string_view<CharT, Traits> sv = t;, entonces inserta los elementos de sv antes del elemento (si es que lo hay) al que apunta pos, como si fuera mediante insert(pos, 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.

11) Implícitamente convierte t a una vista sobre cadena sv como si fuera mediante std::basic_string_view<CharT, Traits> sv = t;, entonces inserta, antes del elemento (si es que lo hay) al que apunta pos, los caracteres de la subvista [index_str, index_str+count) of sv. Si la subvista solicitada se pasa del final de sv, o si count == npos, la subvista resultante es [index_str, sv.size()). Si index_str > sv.size(), o si index > 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

index	-	Posición en la cual se insertará el contenido.
pos	-	Iterador antes del cual se insertarán los caracteres.
ch	-	Carácter a insertar.
count	-	Número de caracteres a insertar.
s	-	Puntero a la cadena de caracteres a insertar.
str	-	Cadena a insertar.
first, last	-	Rango que define los caracteres a insertar.
index_str	-	Posición del primer carácter en la cadena str a insertar.
ilist	-	std::initializer_list de la cual insertar los caracteres.
t	-	Objeto (convertible a std::basic_string_view) del cual insertar los caracteres.
Requisitos de tipo
- InputIt debe satisfacer los requisitos de InputIterator.

Valor de retorno

1-5,10-11)*this

6-9) Un iterador que se refiere a la copia del primer carácter insertado, o pos si no se insertaron caracteres (count==0, o first==last, o ilist.size()==0)

Excepciones

1-4, 10)std::out_of_range si index > size()

5) Lanza std::out_of_range si index > size() o si index_str > str.size().

11) Lanza std::out_of_range si index > size() o si index_str > sv.size().

En todos los casos, lanza std::length_error si size()+ ins_count > max_size(), donde ins_count es el número de caracteres que se insertarán y puede lanzar cualquier excepción lanzada por Allocator::allocate.

En cualquier caso, si se lanza una excepción por cualquier razón, esta función no tiene efecto (garantía de excepción fuerte).

(desde C++11)

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 causa ambigüedad en algunos casos.	Se evitó haciéndola una plantilla.

Ejemplo

Ejecuta este código

#include <cassert>#include <iterator>#include <string>usingnamespace std::string_literals;int main(){std::string s ="jmplr";   // insert(size_type index, size_type count, char ch) s.insert(0, 1, 'E');assert("Ejmplr"== s);   // insert(size_type index, const char* s) s.insert(2, "e");assert("Ejemplr"== s);   // insert(size_type index, string const& str) s.insert(6, "a"s);assert("Ejemplar"== s);   // insert(size_type index, string const& str,// size_type index_str, size_type count) s.insert(8, " es un ejemplo de cadena."s, 0, 14);assert("Ejemplar es un ejemplo"== s);   // insert(const_iterator pos, char ch) s.insert(s.cbegin()+ s.find_first_of('n')+1, ':');assert("Ejemplar es un: ejemplo"== s);   // insert(const_iterator pos, size_type count, char ch) s.insert(s.cbegin()+ s.find_first_of(':')+1, 2, '=');assert("Ejemplar es un:== ejemplo"== s);   // insert(const_iterator pos, InputIt first, InputIt last){std::string seq =" de cadena"; s.insert(s.begin()+ s.find_last_of('e')+1, std::begin(seq), std::end(seq));assert("Ejemplar es un:== ejemplo de cadena"== s);}   // insert(const_iterator pos, std::initializer_list<char>) s.insert(s.cbegin()+ s.find_first_of('g')+1, {'.'});assert("Ejemplar es un:== ejemplo de cadena."== s);}

Véase también

append	Añade caracteres al final (función miembro pública)
push_back	Añade un carácter al final (función miembro pública)