std::pair<T1,T2>::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

 

Dienstprogramm-Bibliotheken

Sprachunterstützung Typunterstützung (Basistypen, RTTI) Bibliotheks-Feature-Test-Makros (C++20) Programm-Dienstprogramme Variadische Funktionen initializer_list (C++11) is_constant_evaluated (C++20) is_within_lifetime (C++26) source_location (C++20) Coroutine-Unterstützung (C++20) Vertragsunterstützung (C++26) Drei-Wege-Vergleich three_way_comparablethree_way_comparable_with (C++20)(C++20) strong_ordering (C++20) weak_ordering (C++20) partial_ordering (C++20) common_comparison_category (C++20) compare_three_way_result (C++20) compare_three_way (C++20) strong_order (C++20) weak_order (C++20) partial_order (C++20) compare_strong_order_fallback (C++20) compare_weak_order_fallback (C++20) compare_partial_order_fallback (C++20)   is_eqis_ltis_lteq (C++20)(C++20)(C++20)   is_neqis_gtis_gteq (C++20)(C++20)(C++20)

Allgemeine Hilfsmittel Funktionsobjekte Bit-Manipulation (C++20) bitset hash (C++11) Relationale Operatoren (in C++20 veraltet) rel_ops::operator!=rel_ops::operator>    rel_ops::operator<=rel_ops::operator>= Ganzzahl-Vergleichsfunktionen cmp_equalcmp_lesscmp_less_than (C++20)(C++20)(C++20)   cmp_not_equalcmp_greatercmp_greater_than (C++20)(C++20)(C++20) in_range (C++20) Swap und Typ-Operationen swap ranges::swap (C++20) exchange (C++14) declval (C++11) to_underlying (C++23) forward (C++11) forward_like (C++23) move (C++11) move_if_noexcept (C++11) as_const (C++17) Gemeinsame Vokabulartypen pair tuple (C++11) optional (C++17) any (C++17) variant (C++17) tuple_size (C++11) tuple_element (C++11) apply (C++17) make_from_tuple (C++17) expected (C++23)

 

std::pair

Memberfunktionen

pair::pair

pair::operator=

pair::swap (C++11)

Nicht-Member-Funktionen

make_pair

operator==operator!=operator<operator<=operator>operator>=operator<=> (bis C++20)(bis C++20)(bis C++20)(bis C++20)(bis C++20)(C++20)

swap(std::pair) (C++11)

get(std::pair) (C++11)

Hilfsklassen

tuple_size<std::pair> (C++11)

tuple_element<std::pair> (C++11)

basic_common_reference<std::pair> (C++23)

common_type<std::pair> (C++23)

formatter<std::pair> (C++23)

piecewise_construct_t (C++11)

Deduktionshilfen(C++17)

 

	(1)
pair& operator=( const pair& other );			(bis C++20)
constexpr pair& operator=( const pair& other );			(seit C++20)
constexpr const pair& operator=( const pair& other ) const;		(2)	(seit C++23)
		(3)
template< class U1, class U2 > pair& operator=( const pair<U1, U2>& other );				(bis C++20)
template< class U1, class U2 > constexpr pair& operator=( const pair<U1, U2>& other );				(seit C++20)
template< class U1, class U2 > constexpr const pair& operator=( const pair<U1, U2>& other ) const;			(4)	(seit C++23)
			(5)
pair& operator=( pair&& other ) noexcept(/* siehe unten */);					(seit C++11) (bis C++20)
constexpr pair& operator=( pair&& other ) noexcept(/* siehe unten */);					(seit C++20)
constexpr const pair& operator=( pair&& other ) const;				(6)	(seit C++23)
				(7)
template< class U1, class U2 > pair& operator=( pair<U1, U2>&& p );						(seit C++11) (bis C++20)
template< class U1, class U2 > constexpr pair& operator=( pair<U1, U2>&& p );						(seit C++20)
template< class U1, class U2 > constexpr const pair& operator=( pair<U1, U2>&& p ) const;					(8)	(seit C++23)
template< pair-like P > constexpr pair& operator=( P&& u );					(9)	(seit C++23)
template< pair-like P > constexpr const pair& operator=( P&& u ) const;					(10)	(seit C++23)

Ersetzt den Inhalt des Paares.

1) Kopierzuweisungsoperator. Ersetzt den Inhalt durch eine Kopie des Inhalts von other.

Der Zuweisungsoperator ist implizit deklariert. Die Verwendung dieses Zuweisungsoperators macht das Programm schlecht geformt, wenn entweder T1 oder T2 ein const-qualifizierter Typ ist, oder ein Referenztyp, oder ein Klassentyp mit einem unzugänglichen Kopierzuweisungsoperator, oder ein Array-Typ einer solchen Klasse.	(bis C++11)
Diese Überladung ist als gelöscht definiert, wenn entweder std::is_copy_assignable<T1>::value oder std::is_copy_assignable<T2>::value false ist.	(seit C++11)

2) Kopierzuweisungsoperator für const-qualifizierte Operanden.

Diese Überladung nimmt nur an der Überladungsauflösung teil, wenn std::is_copy_assignable_v<const T1> und std::is_copy_assignable_v<const T2> beide true sind.

3) Weist other.first first und other.second second zu.

Diese Überladung nimmt nur an der Überladungsauflösung teil, wenn std::is_assignable<T1&, const U1&>::value und std::is_assignable<T2&, const U2&>::value beide true sind.

(seit C++11)

4) Weist other.first first und other.second second zu.

Diese Überladung nimmt nur an der Überladungsauflösung teil, wenn std::is_assignable_v<const T1&, const U1&> und std::is_assignable_v<const T2&, const U2&> beide true sind.

5) Verschiebe-Zuweisungsoperator. Ersetzt den Inhalt durch den von other unter Verwendung von Bewegungssemantik.

Diese Überladung nimmt nur an der Überladungsauflösung teil, wenn std::is_move_assignable<T1>::value und std::is_move_assignable<T2>::value beide true sind.

6) Verschiebe-Zuweisungsoperator für const-qualifizierte Operanden.

Diese Überladung nimmt nur an der Überladungsauflösung teil, wenn std::is_assignable_v<const T1&, T1> und std::is_assignable_v<const T2&, T2> beide true sind.

7) Weist std::forward<U1>(p.first) first und std::forward<U2>(p.second) second zu.

Diese Überladung nimmt nur an der Überladungsauflösung teil, wenn std::is_assignable<T1&, U1>::value und std::is_assignable<T2&, U2>::value beide true sind.

8) Weist std::forward<U1>(p.first) first und std::forward<U2>(p.second) second zu.

Diese Überladung nimmt nur an der Überladungsauflösung teil, wenn std::is_assignable_v<const T1&, U1> und std::is_assignable_v<const T2&, U2> beide true sind.

9) Weist std::get<0>(std::forward<P>(u)) first und std::get<1>(std::forward<P>(u)) second zu.

Diese Überladung nimmt nur an der Überladungsauflösung teil, wenn

• std::same_as<std::remove_cvref_t<P>, std::pair> false ist,
• std::remove_cvref_t<P> keine Spezialisierung von std::ranges::subrange ist,
• std::is_assignable_v<T1&, decltype(std::get<0>(std::forward<P>(p)))> true ist, und
• std::is_assignable_v<T2&, decltype(std::get<1>(std::forward<P>(p)))> true ist.

10) Weist std::get<0>(std::forward<P>(u)) first und std::get<1>(std::forward<P>(u)) second zu.

Diese Überladung nimmt nur an der Überladungsauflösung teil, wenn

• std::same_as<std::remove_cvref_t<P>, std::pair> false ist,
• std::remove_cvref_t<P> keine Spezialisierung von std::ranges::subrange ist,
• std::is_assignable_v<const T1&, decltype(std::get<0>(std::forward<P>(p)))> ist true, und
• std::is_assignable_v<const T2&, decltype(std::get<1>(std::forward<P>(p)))> ist true.

Parameter

Sonstiges	-	Paar von Werten, um den Inhalt dieses Paares zu ersetzen
p	-	Paar von Werten möglicherweise unterschiedlicher Typen, um den Inhalt dieses Paares zu ersetzen
u	-	paar-ähnliches Objekt von Werten, um den Inhalt dieses Paares zu ersetzen
Typanforderungen
- T1 muss die Anforderungen von CopyAssignable von U1 erfüllen. (bis C++11)
- T2 muss die Anforderungen von CopyAssignable von U2 erfüllen. (bis C++11)

Rückgabewert

*this

Ausnahmen

1-4) Kann implementierungsdefinierte Ausnahmen auslösen.

5)

noexcept-Spezifikation:  

noexcept(

    std::is_nothrow_move_assignable<T1>::value &&
    std::is_nothrow_move_assignable<T2>::value

)

6-10) Kann implementierungsdefinierte Ausnahmen auslösen.

Beispiel

Führen Sie diesen Code aus

#include <cstddef>
#include <iomanip>
#include <iostream>
#include <utility>
#include <vector>
 
template<class Os, class T>
Os& operator<<(Os& os, const std::vector<T>& v)
{
    os << '{';
    for (std::size_t t = 0; t != v.size(); ++t)
        os << v[t] << (t + 1 < v.size() ? ", " : "");
    return os << '}';
}
 
template<class Os, class U1, class U2>
Os& operator<<(Os& os, const std::pair<U1, U2>& pair)
{
    return os << '{' << pair.first << ", " << pair.second << '}';
}
 
int main()
{
    std::pair<int, std::vector<int>> p{1, {2}}, q{2, {5, 6}};
 
    p = q; // (1) operator=(const pair& other);
    std::cout << std::setw(23) << std::left
              << "(1) p = q;"
              << "p: " << p << "     q: " << q << '\n';
 
    std::pair<short, std::vector<int>> r{4, {7, 8, 9}};
    p = r; // (3) operator=(const pair<U1, U2>& other);
    std::cout << std::setw(23)
              << "(3) p = r;"
              << "p: " << p << "  r: " << r << '\n';
 
    p = std::pair<int, std::vector<int>>{3, {4}};
    p = std::move(q); // (5) operator=(pair&& other);
    std::cout << std::setw(23)
              << "(5) p = std::move(q);"
              << "p: " << p << "     q: " << q << '\n';
 
    p = std::pair<int, std::vector<int>>{5, {6}};
    p = std::move(r); // (7) operator=(pair<U1, U2>&& other);
    std::cout << std::setw(23)
              << "(7) p = std::move(r);"
              << "p: " << p << "  r: " << r << '\n';
}

Ausgabe

(1) p = q;             p: {2, {5, 6}}     q: {2, {5, 6}}
(3) p = r;             p: {4, {7, 8, 9}}  r: {4, {7, 8, 9}}
(5) p = std::move(q);  p: {2, {5, 6}}     q: {2, {}}
(7) p = std::move(r);  p: {4, {7, 8, 9}}  r: {4, {}}

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 885	C++98	Fehlende heterogene Kopierzuweisung	hinzugefügt (als Überladung (3))
LWG 2729	C++11	pair::operator= war unbeschränkt und könnte zu unnötigem undefiniertem Verhalten führen	eingeschränkt

Siehe auch

operator=

weist den Inhalt eines tuple einem anderen zu (öffentliche Memberfunktion von std::tuple<Types...>)