Namespaces
Variants
Views
Actions

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

From cppreference.com
< cpp‎ | utility‎ | pair
 
 
Utilities library
General utilities
Date and time
Function objects
Formatting library (C++20)
(C++11)
Relational operators (deprecated in C++20)
Integer comparison functions
(C++20)(C++20)(C++20)   
(C++20)
Swap and type operations
(C++14)
(C++11)
(C++11)
(C++11)
(C++17)
Common vocabulary types
(C++11)
(C++17)
(C++17)
(C++17)
(C++11)
(C++17)
(C++23)
Elementary string conversions
(C++17)
(C++17)
 
std::pair
Member functions
pair::operator=
(C++11)
Non-member functions
(until C++20)(until C++20)(until C++20)(until C++20)(until C++20)(C++20)
(C++11)
(C++11)
Deduction guides(C++17)
Helper classes
(C++11)
 
(1)
pair& operator=( const pair& other );
(until C++20)
constexpr pair& operator=( const pair& other );
(since C++20)
constexpr const pair& operator=( const pair& other ) const;
(2) (since C++23)
(3)
template< class U1, class U2 >
pair& operator=( const pair<U1, U2>& other );
(since C++11)
(until C++20)
template< class U1, class U2 >
constexpr pair& operator=( const pair<U1, U2>& other );
(since C++20)
template< class U1, class U2 >
constexpr const pair& operator=( const pair<U1, U2>& other ) const;
(4) (since C++23)
(5)
pair& operator=( pair&& other ) noexcept(/* see below */);
(since C++11)
(until C++20)
constexpr pair& operator=( pair&& other ) noexcept(/* see below */);
(since C++20)
constexpr const pair& operator=( pair&& other ) const;
(6) (since C++23)
(7)
template< class U1, class U2 >
pair& operator=( pair<U1, U2>&& other );
(since C++11)
(until C++20)
template< class U1, class U2 >
constexpr pair& operator=( pair<U1, U2>&& other );
(since C++20)
template< class U1, class U2 >
constexpr const pair& operator=( pair<U1, U2>&& other ) const;
(8) (since C++23)

Replaces the contents of the pair.

1) Copy assignment operator. Replaces the contents with a copy of the contents of other.
  • The assignment operator is implicitly declared. Using this assignment operator makes the program ill-formed if either T1 or T2 is a const-qualified type, or a reference type, or a class type with an inaccessible copy assignment operator, or an array type of such class.
(until C++11)
(since C++11)
2) Copy assignment operator for const-qualified operand.
3) Assigns other.first to first and other.second to second.
4) Assigns other.first to first and other.second to second.
5) Move assignment operator. Replaces the contents with those of other using move semantics.
6) Move assignment operator for const-qualified operand.
7) Assigns std::forward<U1>(p.first) to first and std::forward<U2>(p.second) to second.
8) Assigns std::forward<U1>(p.first) to first and std::forward<U2>(p.second) to second.

Contents

[edit] Parameters

other - pair of values to replace the contents of this pair

[edit] Return value

*this

[edit] Exceptions

1-4) May throw implementation-defined exceptions.
5)
noexcept specification:  
noexcept(

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

)
6-8) May throw implementation-defined exceptions.

[edit] Example

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

Output:

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

[edit] Defect reports

The following behavior-changing defect reports were applied retroactively to previously published C++ standards.

DR Applied to Behavior as published Correct behavior
LWG 2729 C++11 pair::operator= was unconstrained and might
result in unnecessary undefined behavior
constrained

[edit] See also

(C++11)
assigns the contents of one tuple to another
(public member function of std::tuple<Types...>) [edit]