Base de connaissancesCentre d’examen
FRFrançais
Choisir la langue13

CKTIS / C++

std::basic_string::assign — remplacer le contenu d’une chaîne

Choisissez la surcharge selon la source. Pour un tampon de longueur connue, passez un pointeur et un nombre d’éléments afin de conserver les caractères nuls internes.

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

Syntaxe

// 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, déclarée dans <string>, remplace tout le contenu d’une chaîne existante, par exemple un std::string. La méthode renvoie *this par référence, ce qui permet d’enchaîner les appels. Contrairement à append, elle n’ajoute rien à la fin. Les surcharges prenant un basic_string entier se comportent comme operator= par copie ou par déplacement. Le déplacement ne garantit pas la récupération du tampon source, et sa condition noexcept dépend des traits de l’allocateur.

assign(p, count) copie exactement count éléments CharT, y compris les caractères \0 internes. [p, p + count) doit être un intervalle valide et lisible : la fonction ne vérifie pas la taille du tampon. Vérifiez toute longueur non fiable par rapport aux données disponibles avant l’appel. À l’inverse, assign(p) exige une chaîne valide terminée par un caractère nul et copie jusqu’au premier caractère nul, sans l’inclure.

assign(src, pos, count) extrait une portion d’une chaîne ou d’une source assimilable à une vue. Le nombre d’éléments est limité à la longueur restante ; omettre count ou passer npos revient à copier jusqu’à la fin. pos == size() donne un résultat vide ; si pos > size() pour la source, la méthode lève std::out_of_range. Les deux surcharges templates pour les vues (depuis C++17) exigent une conversion implicite de const T& vers le std::basic_string_view correspondant. Seule la surcharge qui prend la source entière exclut la conversion implicite de const T& vers const CharT* ; celle avec pos et count n’impose pas cette restriction.

assign(count, ch) stocke count copies de ch, assign(first, last) copie un intervalle semi-ouvert valide d’itérateurs d’entrée et assign({…}) copie une liste d’initialisation. assign_range(r) est une méthode distincte de C++23 ; sa disponibilité dépend de l’implémentation de la bibliothèque standard.

La copie ne conserve aucune vue sur la source, mais les données sources doivent rester valides pendant la lecture. Après une affectation réussie, récupérez de nouveau les pointeurs, références, itérateurs et vues sur l’ancien contenu de la destination : ils peuvent avoir été invalidés. Un résultat qui dépasserait max_size() provoque std::length_error. Si la méthode lève une exception, la destination reste inchangée ; un intervalle invalide relève du comportement indéfini, pas d’une exception garantie.

Exemples

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

Résultat

size=3
preserved=yes

Le code compare le résultat de `find` à `npos` avant de calculer la position après le séparateur obligatoire `:`. Le tampon n’a pas de caractère nul terminal ; la longueur explicite permet de copier les trois éléments du champ, `A`, `\0` et `B`.

Leçons associées

  • C++ · Leçon 58 · Avancé · Version : 3

Sources