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 seit C++20)
basic_string & operator = ( basic_string && str )
noexcept ( /* siehe unten */ ) ;
(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 . Wenn * this und str dasselbe Objekt sind, hat diese Funktion keine Auswirkung.
2) Ersetzt den Inhalt durch den von str unter Verwendung der Move-Zuweisungssemantik von SequenceContainer .
Im Gegensatz zu anderen Move-Zuweisungen von Sequenzcontainern können Referenzen, Zeiger und Iteratoren auf Elemente von str ungültig werden.
3) Ersetzt den Inhalt durch den der nullterminierten Zeichenkette, auf die s zeigt, als ob durch assign ( s, Traits :: length ( s ) ) .
4) Ersetzt den Inhalt mit dem Zeichen ch als ob durch assign ( std:: addressof ( ch ) , 1 ) .
5) Ersetzt den Inhalt durch den der Initialisierungsliste ilist wie durch assign ( ilist. begin ( ) , ilist. size ( ) ) .
6) Konvertiert implizit t zu einem String-View sv als ob durch std:: basic_string_view < CharT, Traits > sv = t ; , ersetzt dann den Inhalt mit dem von sv als ob durch assign ( sv ) .
Diese Überladung nimmt nur dann 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.

Inhaltsverzeichnis

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> )