Base di conoscenzaCentro esami
ITItaliano
Scegli la lingua13

CKTIS / C++

std::basic_string::assign — sostituire il contenuto di una stringa

Scegli l’overload in base alla sorgente. Per un buffer di lunghezza nota, passa un puntatore e un conteggio per conservare anche i caratteri nulli interni.

Versione: ISO C++23; implementation support may vary

Sintassi

// 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, dichiarata in <string>, sostituisce l’intero contenuto di una stringa esistente, per esempio una std::string. Restituisce *this per riferimento, quindi puoi concatenare le chiamate. A differenza di append, non aggiunge in coda. Gli overload che ricevono una basic_string intera si comportano come operator= di copia o di spostamento. Lo spostamento non garantisce il trasferimento del buffer sorgente e la sua condizione noexcept dipende dai tratti dell’allocatore.

assign(p, count) copia esattamente count elementi CharT, compresi i caratteri \0 interni. [p, p + count) deve essere un intervallo valido e leggibile: la funzione non controlla le dimensioni del buffer. Prima della chiamata, confronta ogni lunghezza non attendibile con i dati disponibili. assign(p), invece, richiede una stringa valida terminata da un carattere nullo e copia solo fino al primo carattere nullo, escluso.

assign(src, pos, count) prende una porzione di una stringa o di una sorgente compatibile con una vista. Il conteggio è limitato alla lunghezza rimanente; omettere count o passare npos significa copiare fino in fondo. pos == size() produce un risultato vuoto; se pos > size() della sorgente, viene lanciata std::out_of_range. Entrambi i template per le viste (da C++17) richiedono la conversione implicita da const T& allo std::basic_string_view corrispondente. Solo il template che riceve la sorgente intera esclude la conversione implicita da const T& a const CharT*; il template con pos e count non impone questo vincolo.

assign(count, ch) memorizza count copie di ch, assign(first, last) copia un intervallo semiaperto valido di iteratori di input e assign({…}) copia una lista di inizializzazione. assign_range(r) è un metodo distinto di C++23; la sua disponibilità dipende dall’implementazione della libreria standard.

La copia non conserva una vista sulla sorgente, ma i dati sorgente devono restare validi durante la lettura. Dopo un’assegnazione riuscita, ottieni nuovamente puntatori, riferimenti, iteratori e viste sul precedente contenuto della destinazione: potrebbero essere stati invalidati. Un risultato che supererebbe max_size() causa std::length_error. Se il metodo lancia un’eccezione, la destinazione non cambia; un intervallo non valido comporta un comportamento indefinito, non un’eccezione garantita.

Esempi

#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';
}

Risultato

size=3
preserved=yes

Il codice confronta il risultato di `find` con `npos` prima di calcolare la posizione dopo il separatore obbligatorio `:`. Il buffer non ha un carattere nullo finale: la lunghezza esplicita permette di copiare tutti e tre gli elementi del campo, `A`, `\0` e `B`.

Lezioni correlate

  • C++ · Lezione 58 · Avanzato · Versione: 3

Fonti