Namespaces
Variants

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

    Von de.cppreference.net
     
    C++
     
    Zeichenkettenbibliothek
     
    std::basic_string
     
    basic_string& operator=( const basic_string& str );
    		(1) (constexpr seit C++20) 
    basic_string& operator=( basic_string&& str )
    noexcept(/* see below */);
    		(2) (seit C++11)
    (constexpr seit C++20)    		 
    basic_string& operator=( const CharT* s );
    		(3) (constexpr seit C++20) 
    basic_string& operator=( CharT ch );
    		(4) (constexpr seit C++20) 
    basic_string& operator=( std::initializer_list<CharT> ilist );
    		(5) (seit C++11)
    (constexpr seit C++20)    		 
    template<class StringViewLike>
basic_string& operator=( const StringViewLike& t );
    		(6) (seit C++17)
    (constexpr seit C++20)    		 
    basic_string& operator=( std::nullptr_t ) = delete;
    		(7) (seit C++23)

    Ersetzt den Inhalt der Zeichenkette.

    1) Ersetzt den Inhalt durch eine Kopie von str. Falls *this und str dasselbe Objekt sind, hat diese Funktion keine Wirkung.
    2) Ersetzt den Inhalt durch den von str unter Verwendung der SequenceContainer-Verschiebungszuweisungssemantik.
    Anders als bei anderen Verschiebungszuweisungen von Sequenzcontainern können Referenzen, Zeiger und Iteratoren auf Elemente von str ungültig gemacht werden.
    3) Ersetzt den Inhalt durch den der nullterminierten Zeichenkette, auf die s zeigt, als ob assign(s, Traits::length(s)) verwendet würde.
    4) Ersetzt den Inhalt durch das Zeichen ch, als ob assign(std::addressof(ch), 1) verwendet würde.
    5) Ersetzt den Inhalt durch den der Initialisierungsliste ilist, als ob assign(ilist.begin(), ilist.size()) verwendet würde.
    6) Konvertiert t implizit in eine String-View sv, als ob std::basic_string_view<CharT, Traits> sv = t; verwendet würde, und ersetzt dann den Inhalt durch den der sv, als ob assign(sv) verwendet würde.
    Diese Überladung nimmt nur an der Überladungsauflösung teil, wenn std::is_convertible_v<const StringViewLike&,
    std::basic_string_view<CharT, Traits>>     true ist und std::is_convertible_v<const StringViewLike&, const CharT*> false ist.
    7) std::basic_string kann nicht von nullptr zugewiesen werden.

    Parameter

    ch - Wert zur Initialisierung der Zeichen des Strings
    str - String, der als Quelle zur Initialisierung des Strings verwendet wird
    s - Zeiger auf eine nullterminierte Zeichenkette, die als Quelle zur Initialisierung des Strings verwendet wird
    ilist - std::initializer_list zur Initialisierung des Strings
    t - in std::basic_string_view konvertierbares Objekt zur Initialisierung des Strings

    Rückgabewert

    * this

    Komplexität

    1) Linear in der Größe von str .
    2) Linear in der Größe von * this (formal muss jedes CharT zerstört werden). Falls Allokatoren nicht gleich sind und sich nicht propagieren, dann ebenfalls linear in der Größe von str (eine Kopie muss erstellt werden).
    3) Linear in der Größe von s .
    4) Konstante.
    5) Linear in der Größe von ilist .
    6) Linear in der Größe von t .

    Ausnahmen

    2)
    noexcept Spezifikation:
    noexcept ( std:: allocator_traits < Allocator > ::

    propagate_on_container_move_assignment :: value ||

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

    Falls die Operation dazu führen würde, dass size() die max_size() überschreitet, wird std::length_error ausgelöst.

    Wenn aus irgendeinem Grund eine Exception ausgelöst wird, hat diese Funktion keine Auswirkung ( strong exception safety guarantee ).

    Beispiel

    Diesen Code ausführen 
    #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'; // "" or "alpha" (unspecified)
    // (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; // equivalent to str1 = static_cast<char>(35U);
    std::cout << std::quoted(str1) << '\n'; // "#" (ASCII = 35)
}

    Mögliche Ausgabe: 

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

    Fehlerberichte

    Die folgenden verhaltensändernden Fehlerberichte wurden rückwirkend auf zuvor veröffentlichte C++-Standards angewendet.

    DR Angewendet auf Verhalten wie veröffentlicht Korrektes Verhalten
    LWG 847 C++98 es gab keine Ausnahmesicherheitsgarantie starke Ausnahmesicherheitsgarantie hinzugefügt
    LWG 2063 C++11 der Move-Zuweisungsoperator folgte nicht
    SequenceContainer 's semantischen Anforderungen     		folgt
    LWG 2946 C++17 Überladung ( 6 ) verursachte in einigen Fällen Mehrdeutigkeit vermieden durch Template-Implementierung

    Siehe auch

    		Konstruiert einen basic_string
    (öffentliche Elementfunktion)
    		Weist Zeichen einem String zu
    (öffentliche Elementfunktion)
    		Weist eine View zu
    (öffentliche Elementfunktion von std::basic_string_view<CharT,Traits> )