CKTIS / C++
std::basic_string::assign — reemplazar el contenido de una cadena
Elige la sobrecarga según el origen. Si el búfer tiene una longitud conocida, pasa un puntero y un número de elementos para conservar los caracteres nulos internos.
Versión: ISO C++23; implementation support may vary
Sintaxis
// ISO C++23 member declarations inside std::basic_string<CharT, Traits, Allocator> (<string>)
constexpr basic_string& assign(const basic_string& str);
constexpr basic_string& assign(basic_string&& str)
noexcept(std::allocator_traits<Allocator>::propagate_on_container_move_assignment::value ||
std::allocator_traits<Allocator>::is_always_equal::value);
constexpr basic_string& assign(const basic_string& str, size_type pos, size_type count = npos);
// Both templates require implicit conversion from const T& to std::basic_string_view<CharT, Traits>.
// Only the whole-source template also requires that const T& not be implicitly convertible to const CharT*.
template<class T> constexpr basic_string& assign(const T& t);
template<class T> constexpr basic_string& assign(const T& t, size_type pos, size_type count = npos);
constexpr basic_string& assign(const CharT* p, size_type count);
constexpr basic_string& assign(const CharT* p);
constexpr basic_string& assign(size_type count, CharT ch);
// InputIt must qualify as an input iterator.
template<class InputIt> constexpr basic_string& assign(InputIt first, InputIt last);
constexpr basic_string& assign(std::initializer_list<CharT> ilist);std::basic_string::assign, declarada en <string>, reemplaza todo el contenido de una cadena existente, como un std::string. Devuelve *this por referencia, de modo que puedes encadenar llamadas. A diferencia de append, no añade nada al final. Las sobrecargas que reciben un basic_string completo actúan como operator= por copia o por movimiento. El movimiento no garantiza que se tome posesión del búfer de origen y su condición noexcept depende de las características del asignador.
assign(p, count) copia exactamente count elementos CharT, incluidos los caracteres \0 internos. [p, p + count) debe ser un rango válido y legible; la función no comprueba el tamaño del búfer. Comprueba cualquier longitud no fiable frente a los datos disponibles antes de llamar. En cambio, assign(p) requiere una cadena válida terminada en nulo y copia hasta el primer nulo sin incluirlo.
assign(src, pos, count) toma un fragmento de una cadena o de un origen compatible con una vista. El número de elementos se limita a la longitud restante; omitir count o pasar npos significa copiar hasta el final. pos == size() produce un resultado vacío; si pos > size() del origen, se lanza std::out_of_range. Ambas plantillas para vistas (desde C++17) exigen una conversión implícita de const T& al std::basic_string_view correspondiente. Solo la plantilla que recibe el origen completo excluye la conversión implícita de const T& a const CharT*; la plantilla con pos y count no impone esa restricción.
assign(count, ch) almacena count copias de ch, assign(first, last) copia un rango semiabierto válido de iteradores de entrada y assign({…}) copia una lista de inicialización. assign_range(r) es un método distinto de C++23; su disponibilidad depende de la implementación de la biblioteca estándar.
La copia no conserva una vista del origen, pero los datos de origen deben seguir siendo válidos durante la lectura. Tras una asignación correcta, vuelve a obtener los punteros, las referencias, los iteradores y las vistas del contenido anterior del destino: pueden haber quedado invalidados. Un resultado que superaría max_size() provoca std::length_error. Si el método lanza una excepción, el destino no cambia; un rango inválido causa comportamiento indefinido, no una excepción garantizada.
Ejemplos
#include <iostream>
#include <string>
#include <string_view>
int main() {
const char buffer[] = {'I', 'D', ':', 'A', '\0', 'B'};
const std::string_view record{buffer, sizeof buffer};
const auto separator = record.find(':');
if (separator == std::string_view::npos) {
std::cerr << "missing separator\n";
return 1;
}
const auto start = separator + 1;
std::string field = "old";
field.assign(record.data() + start, record.size() - start);
std::cout << "size=" << field.size() << '\n';
std::cout << "preserved="
<< (field == std::string("A\0B", 3) ? "yes" : "no") << '\n';
}Resultado
size=3 preserved=yes
El código compara el resultado de `find` con `npos` antes de calcular la posición posterior al separador obligatorio `:`. El búfer no tiene un nulo al final; la longitud explícita copia los tres elementos del campo: `A`, `\0` y `B`.
Lecciones relacionadas
- C++ · Lección 58 · Avanzado · Versión: 3