std::pair::operator=

 

C++

Поддержка компилятором

Автономные и размещённые реализации

Язык

Стандартная библиотека

Заголовки стандартной библиотеки

Требования к именованию

Макросы тестирования функциональности (C++20)

Поддержка языка

Библиотека концептов (C++20)

Библиотека метапрограммирования (C++11)

Библиотека диагностики

Библиотека общих утилит

Библиотека строк

Библиотека контейнеров

Библиотека итераторов

Библиотека диапазонов (C++20)

Библиотека алгоритмов

Библиотека численных данных

Библиотека ввода/вывода

Библиотека локализаций

Регулярные выражения (C++11)

Атомарные операции (C++11)

Библиотека поддержки конкуренции (C++11)

Библиотека файловой системы (C++17)

Технические спецификации

Указатель символов

Внешние библиотеки

 

Библиотека утилит

Языковая поддержка Поддержка типов (базовые типы, RTTI) Макросы тестирования функциональности библиотеки (C++20)     Управление динамической памятью Программные утилиты Поддержка сопрограмм (C++20) Вариативные функции is_constant_evaluated (C++20) is_within_lifetime (C++26) initializer_list (C++11) source_location (C++20) Трёхстороннее сравнение (C++20) three_way_comparablethree_way_comparable_with (C++20)(C++20) strong_ordering (C++20) weak_ordering (C++20) partial_ordering (C++20) common_comparison_category (C++20) compare_three_way_result (C++20) compare_three_way (C++20) strong_order (C++20) weak_order (C++20) partial_order (C++20) compare_strong_order_fallback (C++20) compare_weak_order_fallback (C++20) compare_partial_order_fallback (C++20)     is_eqis_neqis_ltis_lteqis_gtis_gteq (C++20)(C++20)(C++20)(C++20)(C++20)(C++20)

Общие утилиты Дата и время Функциональные объекты Библиотека форматирования (C++20) bitset hash (C++11) Операторы отношения (устарело в C++20) rel_ops::operator!=rel_ops::operator> rel_ops::operator<=rel_ops::operator>= Целочисленные функции сравнения cmp_equalcmp_lesscmp_less_than (C++20)(C++20)(C++20)     cmp_not_equalcmp_greatercmp_greater_than (C++20)(C++20)(C++20) in_range (C++20) Операции обмена и типа swap ranges::swap (C++20) exchange (C++14) declval (C++11) to_underlying (C++23) forward (C++11) forward_like (C++23) move (C++11) move_if_noexcept (C++11) as_const (C++17) Общие лексические типы pair tuple (C++11) optional (C++17) any (C++17) variant (C++17) tuple_size (C++11) tuple_element (C++11) apply (C++17) make_from_tuple (C++17) expected (C++23) Элементарные преобразования строк to_chars (C++17) from_chars (C++17) chars_format (C++17) to_chars_result (C++17) from_chars_result (C++17)

 

std::pair

Функции-элементы

pair::pair

pair::operator=

pair::swap (C++11)

Функции, не являющиеся элементами

make_pair

operator==operator!=operator<operator<=operator>operator>=operator<=> (до C++20)(до C++20)(до C++20)(до C++20)(до C++20)(C++20)

std::swap (C++11)

get (C++11)

Правила вывода(C++17)

Вспомогательные классы

tuple_size (C++11)

tuple_element (C++11)

basic_common_reference (C++23)

common_type (C++23)

piecewise_construct_t (C++11)

 

<tbody> </tbody> <tbody class="t-dcl-rev t-dcl-rev-num "> </tbody><tbody> </tbody> <tbody class="t-dcl-rev t-dcl-rev-num "> </tbody><tbody> </tbody> <tbody class="t-dcl-rev t-dcl-rev-num "> </tbody><tbody> </tbody> <tbody class="t-dcl-rev t-dcl-rev-num "> </tbody><tbody> </tbody>

	(1)
pair& operator=( const pair& other );			(до C++20)
constexpr pair& operator=( const pair& other );			(начиная с C++20)
constexpr const pair& operator=( const pair& other ) const;		(2)	(начиная с C++23)
		(3)
template< class U1, class U2 > pair& operator=( const pair<U1, U2>& other );				(до C++20)
template< class U1, class U2 > constexpr pair& operator=( const pair<U1, U2>& other );				(начиная с C++20)
template< class U1, class U2 > constexpr const pair& operator=( const pair<U1, U2>& other ) const;			(4)	(начиная с C++23)
			(5)
pair& operator=( pair&& other ) noexcept(/* смотрите ниже */);					(начиная с C++11) (до C++20)
constexpr pair& operator=( pair&& other ) noexcept(/* смотрите ниже */);					(начиная с C++20)
constexpr const pair& operator=( pair&& other ) const;				(6)	(начиная с C++23)
				(7)
template< class U1, class U2 > pair& operator=( pair<U1, U2>&& p );						(начиная с C++11) (до C++20)
template< class U1, class U2 > constexpr pair& operator=( pair<U1, U2>&& p );						(начиная с C++20)
template< class U1, class U2 > constexpr const pair& operator=( pair<U1, U2>&& p ) const;					(8)	(начиная с C++23)
template< pair-like P > constexpr pair& operator=( P&& u );					(9)	(начиная с C++23)
template< pair-like P > constexpr const pair& operator=( P&& u ) const;					(10)	(начиная с C++23)

Заменяет содержимое pair.

1) Оператор присваивания копированием. Заменяет содержимое копией содержимого other.

Оператор присваивания объявлен неявно. Использование этого оператора присваивания делает программу некорректной, если либо T1, либо T2 является const-квалифицированным типом, ссылочным типом или классовым типом с недоступным оператором присваивания копированием, или типом массива такого класса.	(до C++11)
Эта перегрузка определяется как удалённая, если std::is_copy_assignable<T1>::value или std::is_copy_assignable<T2>::value равно false.	(начиная с C++11)

2) Оператор присваивания копированием для const-квалифицированного операнда.

Эта перегрузка участвует в разрешении перегрузки, только если std::is_copy_assignable_v<const T1> и std::is_copy_assignable_v<const T2> равны true.

3) Присваивает other.first значению first и other.second значению second.

Эта перегрузка участвует в разрешении перегрузки, только если std::is_assignable<T1&, const U1&>::value и std::is_assignable<T2&, const U2&>::value равны true.

(начиная с C++11)

4) Присваивает other.first значению first и other.second значению second.

Эта перегрузка участвует в разрешении перегрузки, только если std::is_assignable_v<const T1&, const U1&> и std::is_assignable_v<const T2&, const U2&> равны true.

5) Оператор присваивания перемещением. Заменяет содержимое на содержимое other, используя семантику перемещения.

Эта перегрузка участвует в разрешении перегрузки, только если std::is_move_assignable<T1>::value и std::is_move_assignable<T2>::value равны true.

6) Оператор присваивания перемещением для const-квалифицированного операнда.

Эта перегрузка участвует в разрешении перегрузки, только если std::is_assignable_v<const T1&, T1> и std::is_assignable_v<const T2&, T2> равны true.

7) Присваивает std::forward<U1>(p.first) значению first и std::forward<U2>(p.second) значению second.

Эта перегрузка участвует в разрешении перегрузки, только если std::is_assignable<T1&, U1>::value и std::is_assignable<T2&, U2>::value равны true.

8) Присваивает std::forward<U1>(p.first) значению first и std::forward<U2>(p.second) значению second.

Эта перегрузка участвует в разрешении перегрузки, только если std::is_assignable_v<const T1&, U1> и std::is_assignable_v<const T2&, U2> равны true.

9) Присваивает std::get<0>(std::forward<P>(u)) значению first и std::get<1>(std::forward<P>(u)) значению second.

Эта перегрузка участвует в разрешении перегрузки, только если

• std::same_as<std::remove_cvref_t<P>, std::pair> равно false,
• std::remove_cvref_t<P> не является специализацией std::ranges::subrange,
• std::is_assignable_v<T1&, decltype(std::get<0>(std::forward<P>(p)))> равно true, и
• std::is_assignable_v<T1&, decltype(std::get<1>(std::forward<P>(p)))> равно true.

10) Присваивает std::get<0>(std::forward<P>(u)) значению first и std::get<1>(std::forward<P>(u)) значению second.

Эта перегрузка участвует в разрешении перегрузки, только если

• std::same_as<std::remove_cvref_t<P>, std::pair> равно false,
• std::remove_cvref_t<P> не является специализацией std::ranges::subrange,
• std::is_assignable_v<const T1&, decltype(std::get<0>(std::forward<P>(p)))> равно true, и
• std::is_assignable_v<const T1&, decltype(std::get<1>(std::forward<P>(p)))> равно true.

Параметры

other	—	пара значений для замены содержимого этой пары
p	—	пара значений возможно разных типов для замены содержимого этой пары
u	—	объект значений pair-like для замены содержимого этой пары
Требования к типам
- T1 должен соответствовать требованиям CopyAssignable из U1. (до C++11)
- T2 должен соответствовать требованиям CopyAssignable из U2. (до C++11)

Возвращаемое значение

*this

Исключения

1-4) Может генерировать исключения, определённые реализацией.

5)

спецификация noexcept:  

noexcept( std::is_nothrow_move_assignable<T1>::value && std::is_nothrow_move_assignable<T2>::value )

6-10) Может генерировать исключения, определённые реализацией.

Пример

Запустить этот код

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

Вывод:

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

Отчёты о дефектах

Следующие изменения поведения были применены с обратной силой к ранее опубликованным стандартам C++:

Номер	Применён	Поведение в стандарте	Корректное поведение
LWG 885	C++98	отсутствует присваивание гетерогенной копии	добавлено (как перегрузка (3))
LWG 2729	C++11	pair::operator= не был ограничен и мог привести к ненужному неопределённому поведению	ограничен

Смотрите также

operator=

присваивает содержимое одного tuple другому (public функция-элемент std::tuple)