std::pair<T1,T2>::operator=

pair& operator=( const pair& other );	(1)	(constexpr seit C++20)
constexpr const pair& operator=( const pair& other ) const;	(2)	(seit C++23)
template< class U1, class U2 > pair& operator=( const pair<U1, U2>& other );	(3)	(constexpr seit C++20)
template< class U1, class U2 > constexpr const pair& operator=( const pair<U1, U2>& other ) const;	(4)	(seit C++23)
pair& operator=( pair&& other ) noexcept(/* see below */);	(5)	(seit C++11) (constexpr seit C++20)
constexpr const pair& operator=( pair&& other ) const;	(6)	(seit C++23)
template< class U1, class U2 > pair& operator=( pair<U1, U2>&& p );	(7)	(seit C++11) (constexpr 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 pair.

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

Der Zuweisungsoperator wird implizit deklariert. Die Verwendung dieses Zuweisungsoperators macht das Programm fehlerhaft, wenn entweder `T1` oder `T2` ein const-qualifizierter Typ, ein Referenztyp, ein Klassentyp mit einem unzugänglichen Kopierzuweisungsoperator oder ein Array-Typ einer solchen Klasse ist.	(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-qualifizierten 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) Verschiebezuweisungsoperator. Ersetzt den Inhalt durch den von other mittels Verschiebesemantik.

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) Verschiebezuweisungsoperator für const-qualifizierten 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(u)) first und std::get<1>(std::forward(u)) second zu.

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

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

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

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

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

Parameter

other	-	Wertepaar zum Ersetzen der Inhalte dieses Paares
p	-	Wertepaar möglicherweise unterschiedlicher Typen zum Ersetzen der Inhalte dieses Paares
u	-	`pair-like` Objekt von Werten zum Ersetzen der Inhalte dieses Paares
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

Exceptions

1-4) Kann implementierungsdefinierte Ausnahmen werfen.

5)

noexcept Spezifikation:

noexcept (

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

)

6-10) Kann implementierungsdefinierte Ausnahmen werfen.

Beispiel

Diesen Code ausführen

#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	heterogener Kopierzuweisungsoperator fehlte	hinzugefügt (als Überladung (3) )
LWG 2729	C++11	`pair::operator=` war unbegrenzt und könnte zu unnötigem undefiniertem Verhalten führen	begrenzt

Siehe auch

operator=

weist die Inhalte eines


          tuple

einem anderen zu
(öffentliche Elementfunktion von


           std::tuple<Types...>

)

Compilerunterstützung
Freistehend und gehostet
Sprache
Standardbibliothek
Header der Standardbibliothek
Benannte Anforderungen
Feature-Test-Makros (C++20)
Sprachunterstützungsbibliothek
Konzeptbibliothek (C++20)
Diagnosebibliothek
Speicherverwaltungsbibliothek
Metaprogrammierungsbibliothek (C++11)
Allgemeine Dienstprogrammbibliothek
Containerbibliothek
Iteratorenbibliothek
Bereichsbibliothek (C++20)
Algorithmusbibliothek
Zeichenkettenbibliothek
Textverarbeitungsbibliothek
Numerikbibliothek
Datums- und Zeitbibliothek
Eingabe-/Ausgabebibliothek
Dateisystembibliothek (C++17)
Nebenläufigkeitsunterstützungsbibliothek (C++11)
Ausführungssteuerungsbibliothek (C++26)
Technische Spezifikationen
Symbolverzeichnis
Externe Bibliotheken

Mitgliedsfunktionen
pair::pair
pair::operator=
pair::swap (C++11)
Nicht-Mitgliedsfunktionen
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)
Ableitungsleitfäden(C++17)

de.cppreference.net

Namespaces

Variants