Namespaces
Variants

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

From cppreference.net
C++
Utilities library
std::pair
(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 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 dann 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 an first und other. second an second zu.

Diese Überladung nimmt nur dann 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 an first und other. second an second zu.
Diese Überladung nimmt nur dann 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) Move-Zuweisungsoperator. Ersetzt den Inhalt durch den von other unter Verwendung von Move-Semantik.
Diese Überladung nimmt nur dann an der Überladungsauflösung teil, wenn std:: is_move_assignable < T1 > :: value und std:: is_move_assignable < T2 > :: value beide true sind.
6) Move-Zuweisungsoperator für const-qualifizierten Operanden.
Diese Überladung nimmt nur dann 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 ) an first und std:: forward < U2 > ( p. second ) an second zu.
Diese Überladung nimmt nur dann 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 ) an first und std:: forward < U2 > ( p. second ) an second zu.
Diese Überladung nimmt nur dann 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 ) ) an first und std :: get < 1 > ( std:: forward < P > ( u ) ) an second zu.
Diese Überladung nimmt nur dann an der Überladungsauflösung teil, wenn
10) Weist std :: get < 0 > ( std:: forward < P > ( u ) ) an first und std :: get < 1 > ( std:: forward < P > ( u ) ) an second zu.
Diese Überladung nimmt nur dann an der Überladungsauflösung teil, wenn

Inhaltsverzeichnis

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

weist die Inhalte eines tuple einem anderen zu
(öffentliche Elementfunktion von std::tuple<Types...> )