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

 

C++

Compiler-Unterstützung

Freestanding und gehostet

Sprache

Standardbibliothek

Header der Standardbibliothek

Benannte Anforderungen

Feature-Test-Makros (C++20)

Bibliothek für Sprachunterstützung

Konzepte-Bibliothek (C++20)

Diagnostik-Bibliothek

Speicherverwaltungsbibliothek

Metaprogrammierungsbibliothek (C++11)

Allgemeine Dienstprogramme-Bibliothek

Container-Bibliothek

Iterator-Bibliothek

Ranges-Bibliothek (C++20)

Algorithmen-Bibliothek

Bibliothek für Zeichenketten

Textverarbeitungsbibliothek

Numerik-Bibliothek

Datums- und Zeitbibliothek

Ein-/Ausgabe-Bibliothek

Dateisystembibliothek (C++17)

Unterstützung für nebenläufige Programmierung (C++11)

Ausführungssteuerungsbibliothek (C++26)

Technische Spezifikationen

Symbolverzeichnis

Externe Bibliotheken

 

Bibliothek für Zeichenketten

Klassen

basic_string

basic_string_view (C++17)

char_traits

 

std::basic_string

Memberfunktionen basic_string::basic_string basic_string::~basic_string basic_string::operator= basic_string::assign basic_string::assign_range (C++23)   basic_string::get_allocator Elementzugriff basic_string::at basic_string::operator[] basic_string::front (DR*) basic_string::back (DR*) basic_string::data basic_string::c_str basic_string::operator  basic_string_view (C++17) Iteratoren basic_string::beginbasic_string::cbegin (C++11) basic_string::endbasic_string::cend (C++11) basic_string::rbeginbasic_string::crbegin (C++11) basic_string::rendbasic_string::crend (C++11) Suche basic_string::find basic_string::rfind basic_string::find_first_of basic_string::find_first_not_of basic_string::find_last_of basic_string::find_last_not_of

Modifizierer basic_string::clear basic_string::insert basic_string::insert_range (C++23) basic_string::erase basic_string::push_back basic_string::pop_back (DR*) basic_string::append basic_string::append_range (C++23) basic_string::operator+= basic_string::replace basic_string::replace_with_range (C++23) basic_string::copy basic_string::resize basic_string::resize_and_overwrite (C++23)  basic_string::swap Kapazität basic_string::empty basic_string::sizebasic_string::length basic_string::max_size basic_string::reserve basic_string::capacity basic_string::shrink_to_fit (DR*) Operationen basic_string::compare basic_string::starts_with (C++20) basic_string::ends_with (C++20) basic_string::contains (C++23) basic_string::substr

Konstanten basic_string::npos Nicht-Member-Funktionen operator+ swap(std::basic_string) erase(std::basic_string)erase_if(std::basic_string) (C++20)(C++20) I/O operator<<operator>> getline Vergleich operator==operator!=operator<operator>operator<=operator>=operator<=> (bis C++20)(bis C++20)(bis C++20)(bis C++20)(bis C++20)(C++20) Numerische Konvertierungen stoistolstoll (C++11)(C++11)(C++11) stoulstoull (C++11)(C++11)  stofstodstold (C++11)(C++11)(C++11) to_string (C++11) to_wstring (C++11) Literale operator""s (C++14) Hilfsklassen hash<std::basic_string> (C++11) Deduction guides (C++17)

 

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 des Strings.

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 mit dem 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 mit dem von Null-terminiertem Zeichenstring, auf den 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 mit dem von der Initialisierungsliste ilist, als ob durch assign(ilist.begin(), ilist.size()).

6) Konvertiert t implizit in eine String-Ansicht sv, als ob durch std::basic_string_view<CharT, Traits> sv = t;, und ersetzt dann den Inhalt mit dem von sv, als ob durch assign(sv).

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, mit dem die Zeichen des Strings initialisiert werden
str	-	String, der als Quelle zur Initialisierung des Strings verwendet wird
s	-	Zeiger auf einen Null-terminierten Zeichenstring, der als Quelle zur Initialisierung des Strings verwendet wird
ilist	-	std::initializer_list zum Initialisieren des Strings
t	-	Objekt, das in std::basic_string_view konvertierbar ist, zum Initialisieren 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 jeder CharT zerstört werden). Wenn Allocatoren nicht gleich sind und nicht weitergegeben werden, dann auch linear in der Größe von str (Kopie muss erstellt werden).

3) Linear in der Größe von s.

4) Konstant.

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)

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

Wenn aus irgendeinem Grund eine Ausnahme ausgelöst wird, hat diese Funktion keine Auswirkungen (starkes Ausnahmesicherheitsgarantie).

Beispiel

Führen Sie diesen Code aus

#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	Korrigiertes Verhalten
LWG 847	C++98	Es gab keine Ausnahmesicherheitsgarantie	starke Ausnahmesicherheitsgarantie hinzugefügt
LWG 2063	C++11	Der Move-Zuweisungsoperator folgte nicht den semantischen Anforderungen von SequenceContainer	folgt
LWG 2946	C++17	Überladung (6) verursachte in einigen Fällen Mehrdeutigkeit	vermieden durch die Erstellung als Template

Siehe auch

(Konstruktor)	konstruiert einen basic_string (public member function)
assign	weist Zeichen einem String zu (public member function)
operator=	weist eine Ansicht zu (public member function of std::basic_string_view<CharT,Traits>)