std::basic_string::assign

 

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& assign( size_type count, CharT ch );

(hasta C++20)

constexpr basic_string& assign( size_type count, CharT ch );

(desde C++20)

(2)

basic_string& assign(const basic_string& str );

(hasta C++20)

constexpr basic_string& assign(const basic_string& str );

(desde C++20)

(3)

basic_string& assign(const basic_string& str,                       size_type pos, size_type count );

(hasta C++14)

basic_string& assign(const basic_string& str,                       size_type pos, size_type count = npos);

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

constexpr basic_string& assign(const basic_string& str,                                 size_type pos, size_type count = npos);

(desde C++20)

(4)

basic_string& assign( basic_string&& str );

(desde C++11) (hasta C++17)

basic_string& assign( basic_string&& str )noexcept(/* véase más abajo */);

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

constexpr basic_string& assign( basic_string&& str )     noexcept(/* véase más abajo */);

(desde C++20)

(5)

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

(hasta C++20)

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

(desde C++20)

(6)

basic_string& assign(const CharT* s );

(hasta C++20)

constexpr basic_string& assign(const CharT* s );

(desde C++20)

(7)

template<class InputIt > basic_string& assign( InputIt first, InputIt last );

(hasta C++20)

template<class InputIt > constexpr basic_string& assign( InputIt first, InputIt last );

(desde C++20)

(8)

basic_string& assign(std::initializer_list<CharT> ilist );

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

constexpr basic_string& assign(std::initializer_list<CharT> ilist );

(desde C++20)

(9)

template<class T > basic_string& assign(const T& t );

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

template<class T > constexpr basic_string& assign(const T& t );

(desde C++20)

(10)

template<class T > basic_string& assign(const T& t,                       size_type pos, size_type count = npos);

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

template<class T > constexpr basic_string& assign(const T& t,                                 size_type pos, size_type count = npos);

(desde C++20)

Reemplaza el contenido de la cadena.

1) Reemplaza el contenido con count copias del carácter ch.

2) Reemplaza el contenido con una copia de str. Equivalente a *this = str;. En particular, puede tomar lugar la propagación del asignador de memoria.(desde C++11)

3) Reemplaza el contenido conm una subcadena [pos, pos+count) de str. Si la subcadena requerida va más allá del final de la cadena, o si count == npos, la subcadena resultante es [pos, str.size()). Si pos > str.size(), se lanza std::out_of_range.

4) Reemplaza el contenido con el de str usando semántica de movimiento. Equivalente a *this = std::move(str). En particular, puede tomar lugar la propagación del asignador de memoria.

5) Reemplaza el contenido con copias de los caracters en el rango [s, s+count). Este rango puede contener caracteres nulos.

6) Reemplaza el contenido con el de la cadena de caracteres terminada en nulo apuntada por s. La longitud de la cadena se determina por el primer carácter nulo usando Traits::length(s).

7) Reemplaza el contenido con copias de los caracters en el rango [first, last). Esta sobrecarga no participa en la resolución de sobrecarga si InputIt no satisface a InputIterator.(desde C++11)

8) Reemplaza el contenido con el de la lista de inicializadores ilist.

9) Implícitamente convierte t a una vista sobre cadena sv como si fuera mediante std::basic_string_view<CharT, Traits> sv = t;, entonces reemplaza el contenido con el de sv, como si fuera mediante assign(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.

10) Implícitamente convierte t a una vista sobre cadena sv como si fuera mediante std::basic_string_view<CharT, Traits> sv = t;, entonces reemplaza el contenido con los caracteres de la subvista [pos, pos+count) de sv. Si la subvista requerida va más allá del final de sv, o si count == npos, la subvista resultante 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	-	Tamaño de la cadena resultante.
pos	-	Índice del primer carácter a tomar.
ch	-	Valor con el cual inicializar los caracteres de la cadena.
first, last	-	Rango del cual copiar los caracteres.
str	-	Cadena a usarse como fuente con la cual inicializar la cadena.
s	-	Puntero a una cadena de caracteres terminada en nulo con el cual inicializar la cadena.
ilist	-	std::initializer_list con la cual inicializar la cadena.
t	-	Objeto convertible a std::basic_string_view) con el cual inicializar la cadena.
Requisitos de tipo
- InputIt debe satisfacer los requisitos de InputIterator.

Valor de retorno

*this

Complejidad

1) Lineal en count.

2) Lineal en el tamaño de str.

3) Lineal en count.

4) Constante. Si se da alloc y alloc != other.get_allocator(), entonces es lineal.

5) Lineal en count

6) Lineal en el tamaño de s.

7) Lineal en la distancia entre first y last.

8) Lineal en el tamaño de ilist.

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(), se lanza std::length_error.

4) Especificación noexcept:   (desde C++11) noexcept(std::allocator_traits<Allocator>::propagate_on_container_move_assignment::value  ||std::allocator_traits<Allocator>::is_always_equal::value) Ejemplo Ejecuta este código #include <iostream>#include <iterator>#include <string>   int main(){std::string s;// assign(size_type count, CharT ch) s.assign(4, '=');std::cout<< s <<'\n';// "===="   std::stringconst c("Ejemplario");// assign(basic_string const& str) s.assign(c);std::cout<< c <<"=="<< s <<'\n';// "Ejemplario == Ejemplario"   // assign(basic_string const& str, size_type pos, size_type count) s.assign(c, 0, c.length()-1);std::cout<< s <<'\n';// "Ejemplar";   // assign(basic_string&& str) s.assign(std::string("C++ por medio de ")+"ejemplos");std::cout<< s <<'\n';// "C++ por medio de ejemplos"   // assign(charT const* s, size_type count) s.assign("estilo C string", 7);std::cout<< s <<'\n';// "estilo C"   // assign(charT const* s) s.assign("estilo C\0string");std::cout<< s <<'\n';// "estilo C"   char mutable_c_str[]="cadena estilo C";// assign(InputIt first, InputIt last) s.assign(std::begin(mutable_c_str), std::end(mutable_c_str)-1);std::cout<< s <<'\n';// "cadena estilo C"   // assign(std::initializer_list<charT> ilist) s.assign({'C', '-', 's', 't', 'y', 'l', 'e'});std::cout<< s <<'\n';// "estilo C"} Salida: ==== Ejemplario==Ejemplario Ejemplar C++ por medio de ejemplos estilo C estilo C cadena estilo C estilo C

(desde C++17)

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 2063	C++11	Nota no-normativa establecía que swap es una implementación válida de la asignación de movimiento	Corregida para soportar asignadores de memoria
LWG 2579	C++11	assign(const basic_string&) no propaga los asignadores de memoria	Se hizo que propagara los asignadores si es necesario
LWG 2946	C++17	Sobrecarga de string_view causa ambigüedad en algunos casos	Se evitó haciéndola una plantilla

Véase también

(constructor)	Construye una cadena basic_string (función miembro pública)
operator=	Asigna valores a la cadena (función miembro pública)