Espacios de nombres
Variantes
Acciones

Diferencia entre revisiones de «cpp/string/basic string/assign»

De cppreference.com
< cpp‎ | string‎ | basic string
m (1 revisión: Translate from the English version)
m (Cosmético)
 
(No se muestran 6 ediciones intermedias realizadas por 4 usuarios)
Línea 1: Línea 1:
 
{{cpp/string/basic_string/title | assign}}
 
{{cpp/string/basic_string/title | assign}}
 
{{cpp/string/basic_string/navbar}}
 
{{cpp/string/basic_string/navbar}}
−
{{ddcl list begin}}
+
{{begin}}
−
{{ddcl list item | num=1 |
+
{{| num=1
 +
|
 
basic_string& assign( size_type count, CharT ch );
 
basic_string& assign( size_type count, CharT ch );
 +
 +
 
}}
 
}}
−
{{ddcl list item | num=2 |  
+
{{| num=2
 +
|
 
basic_string& assign( const basic_string& str );
 
basic_string& assign( const basic_string& str );
 +
 +
 
}}
 
}}
−
{{ddcl list item | num=3 |
+
{{| num=3
 +
|
 
basic_string& assign( const basic_string& str,
 
basic_string& assign( const basic_string& str,
−
                       size_type pos,
+
                       size_type pos
−
                       size_type count );
+
 +
,
 +
                      
 +
 +
 +
size_type count );
 
}}
 
}}
−
{{ddcl list item | num=4 | notes={{mark since c++11}} |
+
{{| num=4
 +
| =c++11 |
 
basic_string& assign( basic_string&& str );
 
basic_string& assign( basic_string&& str );
 +
 +
 +
 +
 +
 
}}
 
}}
−
{{ddcl list item | num=5 |
+
{{| num=5
−
basic_string& assign( const CharT* s,
+
|
−
                      size_type count );
+
basic_string& assign( const CharT* s,
 +
 +
size_type count );
 
}}
 
}}
−
{{ddcl list item | num=6 |
+
{{| num=6
 +
|
 
basic_string& assign( const CharT* s );
 
basic_string& assign( const CharT* s );
 +
 +
 
}}
 
}}
−
{{ddcl list item | num=7 | 1=
+
{{| num=7
 +
| =
 
template< class InputIt >
 
template< class InputIt >
 
basic_string& assign( InputIt first, InputIt last );
 
basic_string& assign( InputIt first, InputIt last );
 +
 +
 +
 
}}
 
}}
−
{{ddcl list item | num=8 | notes={{mark since c++11}} | 1=
+
{{| num=8
 +
| =c++11 | =
 
basic_string& assign( std::initializer_list<CharT> ilist );
 
basic_string& assign( std::initializer_list<CharT> ilist );
 +
 +
 
}}
 
}}
−
{{ddcl list end}}
+
{{
 +
 +
 +
 +
 +
 +
 +
 +
 +
 +
 +
 +
 +
 +
 +
 +
 +
 +
end}}
  
−
{{tr|Reemplaza el contenido de la cadena .|Replaces the contents of the string.}}
+
Reemplaza el contenido de la cadena.
  
−
1) {{tr|Reemplaza el contenido con las copias de {{tt|count}} {{tt|ch}} charactor|Replaces the contents with {{tt|count}} copies of charactor {{tt|ch}}}}
+
1Reemplaza el contenido con {{tt|count}} {{tt|ch}}
  
−
2) {{tr|Reemplaza el contenido de una copia de {{tt|str}}|Replaces the contents with a copy of {{tt|str}}}}
+
2Reemplaza el contenido una copia de {{tt|str}}a {{|str}}}}
  
−
3) {{tr|Reemplaza el contenido con un {{tt|[pos, pos+count)}} subcadena de {{tt|str}}. Si la subcadena solicitado dura más allá del final de la cadena, o si {{c|1=count == npos}}, la subcadena resultante es {{tt|[pos, size())}}. Si {{c|1=pos >= str.size()}}, {{c|std::out_of_range}} se produce . |Replaces the contents with a substring {{tt|[pos, pos+count)}} of {{tt|str}}. If the requested substring lasts past the end of the string, or if {{c|1=count == npos}}, the resulting substring is {{tt|[pos, size())}}.  If {{c|1=pos >= str.size()}}, {{c|std::out_of_range}} is thrown. }}
+
3Reemplaza el contenido {{tt|[pos, pos+count)}} de {{tt|str}}. Si la subcadena más allá del final de la cadena, o si {{c|1=count == npos}}, la subcadena resultante es {{tt|[pos, size())}}. Si {{c|1=pos > str.size()}}, se {{|std::out_of_range}}.  
  
−
4) {{tr|Reemplaza el contenido con los de {{tt|str}} utilizando la semántica de movimiento. {{tt|str}} se encuentra en estado indefinido después de la operación .|Replaces the contents with those of {{tt|str}} using move semantics. {{tt|str}} is in undefined state after the operation.}}
+
4Reemplaza el contenido con de {{tt|str}} semántica de movimiento. {{|str}}de .
  
−
5) {{tr|Reemplaza el contenido con los personajes {{tt|count}} primeros cadena de caracteres apuntada por {{tt|s}}. {{tt|s}} puede contener caracteres nulos .|Replaces the contents with the first {{tt|count}} characters of character string pointed to by {{tt|s}}. {{tt|s}} can contain null characters.}}
+
5Reemplaza el contenido con los {{tt|count}}. puede contener caracteres nulos.
  
−
6) {{tr|Reemplaza el contenido con los de cadena de caracteres terminada en cero que apunta {{tt|s}}. La longitud de la cadena se determina por el primer carácter nulo . |Replaces the contents with those of null-terminated character string pointed to by {{tt|s}}. The length of the string is determined by the first null character. }}
+
6Reemplaza el contenido con de cadena de caracteres terminada en {{tt|s}}. La longitud de la cadena se determina por el primer carácter nulo {{|s}}.  
  
−
7) {{tr|Reemplaza el contenido con las copias de los personajes de la serie {{tt|[first, last)}}|Replaces the contents with copies of the characters in the range {{tt|[first, last)}}}}
+
7Reemplaza el contenido con copias de los {{tt|[first, last)}}|{{tt|}}}}
  
−
8) {{tr|Reemplaza el contenido con los de la lista de inicialización {{tt|ilist}} .|Replaces the contents with those of the initializer list {{tt|ilist}}.}}
+
8
 +
 
 +
)
 +
 
 +
{{|el contenido con los de la de {{tt|}}. |{{tt|}}.}}
  
 
===Parámetros===
 
===Parámetros===
−
{{param list begin}}
+
{{begin}}
−
{{param list item | count |{{tr| tamaño de la cadena resultante| size of the resulting string}}}}
+
{{| count | de la cadena resultante}}
−
{{param list item | ch |{{tr| valor para inicializar caracteres de la cadena con| value to initialize characters of the string with}}}}
+
}}
−
{{param list item | first, last |{{tr| van a copiar los caracteres de| range to copy the characters from}}}}
+
{{| ch | inicializar caracteres de la cadena}}
−
{{param list item | str |{{tr| cadena a ser usada como fuente para inicializar los caracteres con| string to be used as source to initialize the characters with}}}}
+
{{| first, last | copiar los caracteres}}
−
{{param list item | s |{{tr| puntero a una cadena de caracteres a use<br> como fuente para inicializar la cadena con| pointer to a character string to use<br> as source to initialize the string with}}}}
+
{{| str | a como fuente inicializar }}
−
{{param list item | init |{{tr| lista de inicializadores para inicializar los caracteres de la cadena con| initializer list to initialize the characters of the string with}}}}
+
{{| s | a una cadena de caracteres inicializar la cadena
−
{{param list hreq}}
+
| }} }}
−
{{param list req concept | InputIt | InputIterator}}
+
{{| | {{|inicializar la cadena}}
−
{{param list end}}  
+
{{hreq}}
 +
{{req | InputIt | InputIterator}}
 +
{{end}}
  
 
===Valor de retorno===
 
===Valor de retorno===
Línea 66: Línea 120:
  
 
===Complejidad===
 
===Complejidad===
−
1) {{tr|lineal en {{tt|count}}|linear in {{tt|count}}}}
 
  
−
2) {{tr|lineal en el tamaño de {{tt|str}}|linear in size of {{tt|str}}}}
+
en {{tt|}}
  
−
3) {{tr|lineal en {{tt|count}}|linear in {{tt|count}}}}
+
en {{tt|}}
  
−
4) {{tr|constante. Si {{tt|alloc}} se da y {{c|alloc !{{=}} other.get_allocator()}}, lineal entonces .|constant. If {{tt|alloc}} is given and {{c|alloc !{{=}} other.get_allocator()}}, then linear.}}
+
{{tt|}}.
  
−
5) {{tr|lineal en {{tt|count}}|linear in {{tt|count}}}}
+
{{tt|}} |{{}} }}
  
−
6) {{tr|lineal en el tamaño de {{tt|s}}|linear in size of {{tt|s}}}}
+
en {{tt|}}
  
−
7) {{tr|lineal en distancia entre {{tt|first}} y {{tt|last}}|linear in distance between {{tt|first}} and {{tt|last}}}}
+
en {{tt|}}
  
−
8) {{tr|lineal en el tamaño de {{tt|init}}|linear in size of {{tt|init}}}}
+
{{|
 +
 
 +
en el tamaño de {{tt|}}
 +
 
 +
 +
|
 +
 +
 
 +
{{tt|
 +
 
 +
 +
 +
}} }}
  
 
===Ejemplo===
 
===Ejemplo===
 
{{example
 
{{example
 
  | code=
 
  | code=
 +
 +
 +
 +
 +
 +
 +
 +
 +
 +
 +
 +
 +
 +
 +
 +
 +
 +
 +
 +
 +
 +
 +
 +
 +
 +
 +
 +
 +
 +
 +
 +
 +
 +
 +
 +
 +
 +
 +
 +
 +
 
  | output=
 
  | output=
 +
 +
 +
 +
 +
 +
 +
 +
 
}}
 
}}
 +
 +
 +
 +
 +
 +
 +
 +
  
−
===Ver también===
+
===también===
−
{{dcl list begin}}
+
{{begin}}
−
{{dcl list template | cpp/string/basic_string/dcl list constructor}}
+
{{| cpp/string/basic_string/constructor}}
−
{{dcl list template | cpp/string/basic_string/dcl list operator{{=}}}}
+
{{| cpp/string/basic_string/operator{{=}}}}
−
{{dcl list end}}
+
{{end}}
  
−
[[it:cpp/string/basic string/assign]]
+
itjaplptru
−
[[ja:cpp/string/basic string/assign]]
+
−
[[pl:cpp/string/basic string/assign]]
+
−
[[pt:cpp/string/basic string/assign]]
+
−
[[ru:cpp/string/basic string/assign]]
+

Última revisión de 07:31 1 oct 2020

 
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
 
(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.

Contenido

[editar] 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.

[editar] Valor de retorno

*this

[editar] 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.

[editar] 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::string const 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)

[editar] 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

[editar] Véase también

 Construye una cadena basic_string
(función miembro pública) [editar]
Asigna valores a la cadena
(función miembro pública) [editar]
Obtenido de «https://es.cppreference.com/mwiki/index.php?title=cpp/string/basic_string/assign&oldid=37583»