Namespaces
Variants

std::basic_string<CharT,Traits,Allocator>:: operator=

From cppreference.net
C++
Strings library
std::basic_string
basic_string & operator = ( const basic_string & str ) ;
(1) (constexpr depuis C++20)
basic_string & operator = ( basic_string && str )
noexcept ( /* voir ci-dessous */ ) ;
(2) (depuis C++11)
(constexpr depuis C++20)
basic_string & operator = ( const CharT * s ) ;
(3) (constexpr depuis C++20)
basic_string & operator = ( CharT ch ) ;
(4) (constexpr depuis C++20)
basic_string & operator = ( std:: initializer_list < CharT > ilist ) ;
(5) (depuis C++11)
(constexpr depuis C++20)
template < class StringViewLike >
basic_string & operator = ( const StringViewLike & t ) ;
(6) (depuis C++17)
(constexpr depuis C++20)
basic_string & operator = ( std:: nullptr_t ) = delete ;
(7) (depuis C++23)

Remplace le contenu de la chaîne.

1) Remplace le contenu par une copie de str . Si * this et str sont le même objet, cette fonction n'a aucun effet.
2) Remplace le contenu par celui de str en utilisant SequenceContainer la sémantique d'affectation par déplacement.
Contrairement aux autres affectations par déplacement des conteneurs de séquence, les références, pointeurs et itérateurs vers les éléments de str peuvent être invalidés.
3) Remplace le contenu par celui de la chaîne de caractères terminée par un caractère nul pointée par s comme par assign ( s, Traits :: length ( s ) ) .
4) Remplace le contenu par le caractère ch comme par assign ( std:: addressof ( ch ) , 1 ) .
5) Remplace le contenu par celui de la liste d'initialisation ilist comme si en utilisant assign ( ilist. begin ( ) , ilist. size ( ) ) .
6) Convertit implicitement t en une vue de chaîne sv comme si par std:: basic_string_view < CharT, Traits > sv = t ; , puis remplace le contenu par celui de sv comme si par assign ( sv ) .
Cette surcharge participe à la résolution de surcharge seulement si std:: is_convertible_v < const StringViewLike & ,
std:: basic_string_view < CharT, Traits >> est true et std:: is_convertible_v < const StringViewLike & , const CharT * > est false .
7) std::basic_string ne peut pas être assigné à partir de nullptr .

Table des matières

Paramètres

ch - valeur pour initialiser les caractères de la chaîne
str - chaîne à utiliser comme source pour initialiser la chaîne
s - pointeur vers une chaîne de caractères terminée par un caractère nul à utiliser comme source pour initialiser la chaîne
ilist - std::initializer_list pour initialiser la chaîne
t - objet convertible en std::basic_string_view pour initialiser la chaîne

Valeur de retour

* this

Complexité

1) Linéaire en fonction de la taille de str .
2) Linéaire dans la taille de * this (formellement, chaque CharT doit être détruit). Si les allocateurs ne sont pas égaux et ne se propagent pas, alors également linéaire dans la taille de str (une copie doit être faite).
3) Linéaire en fonction de la taille de s .
4) Constante.
5) Linéaire en fonction de la taille de ilist .
6) Linéaire en fonction de la taille de t .

Exceptions

2)
noexcept spécification :
noexcept ( std:: allocator_traits < Allocator > ::

propagate_on_container_move_assignment :: value ||

std:: allocator_traits < Allocator > :: is_always_equal :: value )

Si l'opération devait entraîner le dépassement de size() au-delà de max_size() , lève std::length_error .

Si une exception est levée pour quelque raison que ce soit, cette fonction n'a aucun effet ( strong exception safety guarantee ).

Exemple

Exécuter ce code 
#include <iomanip>
#include <iostream>
#include <string>
int main()
{
    std::string str1;
    std::string str2{"alpha"};
    // (1) operator=(const basic_string&);
    str1 = str2;
    std::cout << std::quoted(str1) << ' '   // "alpha"
              << std::quoted(str2) << '\n'; // "alpha"
    // (2) operator=(basic_string&&);
    str1 = std::move(str2);
    std::cout << std::quoted(str1) << ' '   // "alpha"
              << std::quoted(str2) << '\n'; // "" ou "alpha" (non spécifié)
    // (3) operator=(const CharT*);
    str1 = "beta";
    std::cout << std::quoted(str1) << '\n'; // "beta"
    // (4) operator=(CharT);
    str1 = '!'; 
    std::cout << std::quoted(str1) << '\n'; // "!"
    // (5) operator=(std::initializer_list<CharT>);
    str1 = {'g', 'a', 'm', 'm', 'a'};
    std::cout << std::quoted(str1) << '\n'; // "gamma"
    // (6) operator=(const T&);
    str1 = 35U; // équivalent à str1 = static_cast<char>(35U);
    std::cout << std::quoted(str1) << '\n'; // "#" (ASCII = 35)
}

Sortie possible : 

"alpha" "alpha"
"alpha" ""
"beta"
"!"
"gamma"
"#"

Rapports de défauts

Les rapports de défauts modifiant le comportement suivants ont été appliqués rétroactivement aux normes C++ précédemment publiées.

DR Appliqué à Comportement publié Comportement corrigé
LWG 847 C++98 aucune garantie de sécurité des exceptions n'était fournie garantie de sécurité forte des exceptions ajoutée
LWG 2063 C++11 l'opérateur d'affectation de déplacement ne respectait pas
SequenceContainer l'exigence sémantique de 		respecte
LWG 2946 C++17 la surcharge ( 6 ) provoquait une ambiguïté dans certains cas évitée en la transformant en template

Voir aussi

construit une basic_string
(fonction membre publique)
assigne des caractères à une chaîne
(fonction membre publique)
assigne une vue
(fonction membre publique de std::basic_string_view<CharT,Traits> )