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

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

Remplace le contenu de la paire.

1) Opérateur d'affectation par copie. Remplace le contenu par une copie du contenu de other.

L'opérateur d'affectation est implicitement déclaré. L'utilisation de cet opérateur d'affectation rend le programme mal formé si `T1` ou `T2` est un type qualifié const, ou un type référence, ou un type de classe avec un opérateur d'affectation par copie inaccessible, ou un type tableau d'une telle classe.	(jusqu'à C++11)
Cette surcharge est définie comme supprimée si `std::is_copy_assignable<T1>::value` ou `std::is_copy_assignable<T2>::value` est `false`.	(depuis C++11)

2) Opérateur d'affectation par copie pour un opérande qualifié const.

Cette surcharge participe à la résolution de surcharge seulement si std::is_copy_assignable_v<const T1> et std::is_copy_assignable_v<const T2> sont tous deux true.

3) Assigne other.first à first et other.second à second.

Cette surcharge participe à la résolution de surcharge seulement si std::is_assignable<T1&, const U1&>::value et std::is_assignable<T2&, const U2&>::value sont tous deux true.

(depuis C++11)

4) Assigne other.first à first et other.second à second.

Cette surcharge participe à la résolution de surcharge seulement si std::is_assignable_v<const T1&, const U1&> et std::is_assignable_v<const T2&, const U2&> sont tous deux true.

5) Opérateur d'affectation par déplacement. Remplace le contenu par celui de other en utilisant la sémantique de déplacement.

Cette surcharge participe à la résolution de surcharge seulement si std::is_move_assignable<T1>::value et std::is_move_assignable<T2>::value sont tous deux true.

6) Opérateur d'affectation par déplacement pour un opérande qualifié const.

Cette surcharge participe à la résolution de surcharge seulement si std::is_assignable_v<const T1&, T1> et std::is_assignable_v<const T2&, T2> sont tous deux true.

7) Assigne std::forward<U1>(p.first) à first et std::forward<U2>(p.second) à second.

Cette surcharge participe à la résolution de surcharge seulement si std::is_assignable<T1&, U1>::value et std::is_assignable<T2&, U2>::value sont tous deux true.

8) Assigne std::forward<U1>(p.first) à first et std::forward<U2>(p.second) à second.

Cette surcharge participe à la résolution de surcharge seulement si std::is_assignable_v<const T1&, U1> et std::is_assignable_v<const T2&, U2> sont tous deux true.

9) Assigne std::get<0>(std::forward(u)) à first et std::get<1>(std::forward(u)) à second.

Cette surcharge participe à la résolution de surcharge seulement si

std::same_as<std::remove_cvref_t, std::pair> est false,
std::remove_cvref_t n'est pas une spécialisation de std::ranges::subrange,
std::is_assignable_v<T1&, decltype(std::get<0>(std::forward(p)))> est true, et
std::is_assignable_v<T1&, decltype(std::get<1>(std::forward(p)))> est true.

10) Assigne std::get<0>(std::forward(u)) à first et std::get<1>(std::forward(u)) à second.

Cette surcharge participe à la résolution de surcharge seulement si

std::same_as<std::remove_cvref_t, std::pair> est false,
std::remove_cvref_t n'est pas une spécialisation de std::ranges::subrange,
std::is_assignable_v<const T1&, decltype(std::get<0>(std::forward(p)))> est true, et
std::is_assignable_v<const T1&, decltype(std::get<1>(std::forward(p)))> est true.

Paramètres

other	-	paire de valeurs pour remplacer le contenu de cette paire
p	-	paire de valeurs de types potentiellement différents pour remplacer le contenu de cette paire
u	-	`pair-like` objet de valeurs pour remplacer le contenu de cette paire
Exigences de type
- `T1` doit satisfaire aux exigences de CopyAssignable depuis `U1` . (jusqu'à C++11)
- `T2` doit satisfaire aux exigences de CopyAssignable depuis `U2` . (jusqu'à C++11)

Valeur de retour

* this

Exceptions

1-4) Peut lever des exceptions définies par l'implémentation.

5)

noexcept spécification :

noexcept (

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

)

6-10) Peut lever des exceptions définies par l'implémentation.

Exemple

Exécuter ce code

#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';
}

Sortie :

(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, {}}

Rapports de défauts

Les rapports de défauts modifiant le comportement suivants ont été appliqués rétroactivement aux normes C++ précédemment publiées.

DR	Appliqué à	Comportement publié	Comportement corrigé
LWG 885	C++98	assignation de copie hétérogène manquante	ajoutée (comme surcharge (3) )
LWG 2729	C++11	`pair::operator=` n'était pas contraint et pouvait entraîner un comportement indéfini inutile	contraint

Voir aussi

operator=

assigne le contenu d'un


          tuple

à un autre
(fonction membre publique de


           std::tuple<Types...>

)

Support du compilateur
Autonome et hébergé
Langage
Bibliothèque standard
En-têtes de la bibliothèque standard
Exigences nommées
Macros de test de fonctionnalités (C++20)
Bibliothèque de support langage
Bibliothèque de concepts (C++20)
Bibliothèque de diagnostics
Bibliothèque de gestion de la mémoire
Bibliothèque de métaprogrammation (C++11)
Bibliothèque d'utilitaires généraux
Bibliothèque de conteneurs
Bibliothèque d'itérateurs
Bibliothèque de plages (C++20)
Bibliothèque d'algorithmes
Bibliothèque de chaînes
Bibliothèque de traitement de texte
Bibliothèque numérique
Bibliothèque de date et heure
Bibliothèque d'entrée/sortie
Bibliothèque de système de fichiers (C++17)
Bibliothèque de support de la concurrence (C++11)
Bibliothèque de contrôle d'exécution (C++26)
Spécifications techniques
Index des symboles
Bibliothèques externes

Fonctions membres
pair::pair
pair::operator=
pair::swap (C++11)
Fonctions non membres
make_pair
operator==operator!=operator<operator<=operator>operator>=operator<=> (jusqu'à C++20)(jusqu'à C++20)(jusqu'à C++20)(jusqu'à C++20)(jusqu'à C++20)(C++20)
swap(std::pair) (C++11)
get(std::pair) (C++11)
Classes auxiliaires
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)
Guides de déduction(C++17)

fr.cppreference.net

Namespaces

Variants