Namespaces
Variants

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

From cppreference.net
C++
Utilities library
std::pair
Traductions effectuées : - "see below" → "voir ci-dessous" - "since" → "depuis" - "until" → "jusqu'à" Les éléments suivants ont été préservés : - Toutes les balises HTML et leurs attributs - Le contenu des balises ` ` (implicite dans `mw-geshi cpp`) - La terminologie C++ spécifique (pair, operator, noexcept, constexpr) - La structure et le formatage d'origine
(1)
pair & operator = ( const pair & other ) ;
(jusqu'à C++20)
constexpr pair & operator = ( const pair & other ) ;
(depuis C++20)
constexpr const pair & operator = ( const pair & other ) const ;
(2) (depuis C++23)
(3)
template < class U1, class U2 >
pair & operator = ( const pair < U1, U2 > & other ) ;
(jusqu'au C++20)
template < class U1, class U2 >
constexpr pair & operator = ( const pair < U1, U2 > & other ) ;
(depuis C++20)
template < class U1, class U2 >
constexpr const pair & operator = ( const pair < U1, U2 > & other ) const ;
(4) (depuis C++23)
(5)
pair & operator = ( pair && other ) noexcept ( /* voir ci-dessous */ ) ;
(depuis C++11)
(jusqu'à C++20)
constexpr pair & operator = ( pair && other ) noexcept ( /* voir ci-dessous */ ) ;
(depuis C++20)
constexpr const pair & operator = ( pair && other ) const ;
(6) (depuis C++23)
(7)
template < class U1, class U2 >
pair & operator = ( pair < U1, U2 > && p ) ;
(depuis C++11)
(jusqu'à C++20)
template < class U1, class U2 >
constexpr pair & operator = ( pair < U1, U2 > && p ) ;
(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, un type référence, un type classe avec un opérateur d'affectation par copie inaccessible, ou un type tableau d'une telle classe.

(jusqu'en 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) Affecte 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) Affecte 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) Affecte 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) Affecte 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) Affecte std :: get < 0 > ( std:: forward < P > ( u ) ) à first et std :: get < 1 > ( std:: forward < P > ( u ) ) à second .
Cette surcharge participe à la résolution de surcharge seulement si
10) Affecte std :: get < 0 > ( std:: forward < P > ( u ) ) à first et std :: get < 1 > ( std:: forward < P > ( u ) ) à second .
Cette surcharge participe à la résolution de surcharge seulement si

Table des matières

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

assigne le contenu d'un tuple à un autre
(fonction membre publique de std::tuple<Types...> )