std::tuple::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::tuple

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

tuple::tuple

tuple::operator=

tuple::swap

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

make_tuple

tie

forward_as_tuple

tuple_cat

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

std::swap

get

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

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

tuple-like (C++23)

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

tuple_size

tuple_element

uses_allocator

basic_common_reference (C++23)

common_type (C++23)

ignore

 

<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> <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)
tuple& operator=( const tuple& other );			(начиная с C++11) (до C++20)
constexpr tuple& operator=( const tuple& other );			(начиная с C++20)
constexpr const tuple& operator=( const tuple& other ) const;		(2)	(начиная с C++23)
		(3)
tuple& operator=( tuple&& other ) noexcept(/* смотрите ниже */);				(начиная с C++11) (до C++20)
constexpr tuple& operator=( tuple&& other ) noexcept(/* смотрите ниже */);				(начиная с C++20)
constexpr const tuple& operator=( tuple&& other ) const;			(4)	(начиная с C++23)
			(5)
template< class... UTypes > tuple& operator=( const tuple<UTypes...>& other );					(начиная с C++11) (до C++20)
template< class... UTypes > constexpr tuple& operator=( const tuple<UTypes...>& other );					(начиная с C++20)
template< class... UTypes > constexpr const tuple& operator=( const tuple<UTypes...>& other ) const;				(6)	(начиная с C++23)
				(7)
template< class... UTypes > tuple& operator=( tuple<UTypes...>&& other );						(начиная с C++11) (до C++20)
template< class... UTypes > constexpr tuple& operator=( tuple<UTypes...>&& other );						(начиная с C++20)
template< class... UTypes > constexpr const tuple& operator=( tuple<UTypes...>&& other ) const;					(8)	(начиная с C++23)
					(9)
template< class E1, class E2 > tuple& operator=( const std::pair<E1, E2>& p );							(начиная с C++11) (до C++20)
template< class E1, class E2 > constexpr tuple& operator=( const std::pair<E1, E2>& p );							(начиная с C++20)
template< class E1, class E2 > constexpr const tuple& operator=( const std::pair<E1, E2>& p ) const;						(10)	(начиная с C++23)
						(11)
template< class E1, class E2 > tuple& operator=( std::pair<E1, E2>&& p );								(начиная с C++11) (до C++20)
template< class E1, class E2 > constexpr tuple& operator=( std::pair<E1, E2>&& p );								(начиная с C++20)
template< class E1, class E2 > constexpr const tuple& operator=( std::pair<E1, E2>&& p ) const;							(12)	(начиная с C++23)
template< tuple-like UTuple > constexpr tuple& operator=( UTuple&& u );							(13)	(начиная с C++23)
template< tuple-like UTuple > constexpr const tuple& operator=( UTuple&& u ) const;							(14)	(начиная с C++23)

Заменяет содержимое tuple содержимым другого tuple-like объекта.

В последующих описаниях пусть

• i находиться в диапазоне [​0​, sizeof...(Types)) по порядку,
• Ti должен быть i-м типом в пакете параметров шаблона класса Types, и
• Ui должен быть i-м типом в пакете параметров шаблона функции с именем UTypes,

где индексация начинается с нуля.

1) Оператор присваивания копированием. Присваивает каждый элемент other соответствующему элементу *this.

Эта перегрузка определяется как удалённая, если только std::is_copy_assignable<Ti>::value не равно true для всех Ti.

2) Оператор присваивания копированием для const-квалифицированного операнда. Присваивает каждый элемент other соответствующему элементу *this.

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

3) Оператор присваивания перемещением. Для всех i присваивает std::forward<Ti>(std::get<i>(other)) значению std::get<i>(*this).

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

4) Оператор присваивания перемещением с const-квалифицированным операндом. Для всех i, присваивает std::forward<Ti>(std::get<i>(other)) значению std::get<i>(*this).

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

5) Для всех i присваивает std::get<i>(other) значению std::get<i>(*this).

{{cpp/enable_if|sizeof...(Types) == sizeof...(UTypes) и std::is_assignable<Ti&, const Ui&>::value равно true для всех соответствующих пар типов Ti и Ui}.

6) Для всех i присваивает std::get<i>(other) значению std::get<i>(*this).

Эта перегрузка участвует в разрешении перегрузки, только если sizeof...(Types) == sizeof...(UTypes) и std::is_assignable_v<const Ti&, const Ui&> равно true для всех соответствующих пар типов Ti и Ui.

7) Для всех i присваивает std::forward<Ui>(std::get<i>(other)) значению std::get<i>(*this).

Эта перегрузка участвует в разрешении перегрузки, только если sizeof...(Types) == sizeof...(UTypes) и std::is_assignable<Ti&, Ui>::value равно true для всех соответствующих пар типов Ti и Ui.

8) Для всех i присваивает std::forward<Ui>(std::get<i>(other)) значению std::get<i>(*this).

Эта перегрузка участвует в разрешении перегрузки, только если sizeof...(Types) == sizeof...(UTypes) и std::is_assignable_v<const Ti&, Ui> равно true для всех соответствующих пар типов Ti и Ui.

9) Присваивает p.first первому элементу *this и p.second второму элементу *this.

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

• sizeof...(Types) == 2,
• std::is_assignable<T0&, const E1&>::value равно true, и
• std::is_assignable<T1&, const E2&>::value равно true.

10) Присваивает p.first первому элементу и p.second второму элементу.

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

• sizeof...(Types) == 2,
• std::is_assignable_v<const T0&, const E1&> равно true, и
• std::is_assignable_v<const T1&, const E2&> равно true.

11) Присваивает std::forward<E1>(p.first) первому элементу *this и std::forward<E2>(p.second) второму элементу *this.

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

• sizeof...(Types) == 2,
• std::is_assignable_v<T0&, E1> равно true, и
• std::is_assignable_v<T1&, E2> равно true.

12) Присваивает std::forward<E1>(p.first) первому элементу и std::forward<E2>(p.second) второму элементу.

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

• sizeof...(Types) == 2,
• std::is_assignable_v<const T0&, E1> равно true, и
• std::is_assignable_v<const T1&, E2> равно true.

13) Для всех i присваивает std::get<i>(std::forward<UTuple>(u)) значению std::get<i>(*this).

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

• std::same_as<std::remove_cvref_t<UTuple>, std::tuple> равно false,
• std::remove_cvref_t<UTuple> не является специализацией std::ranges::subrange,
• sizeof...(Types) равно std::tuple_size_v<std::remove_cvref_t<UTuple>>, и
• std::is_assignable_v<Ti&, decltype(std::get<i>(std::forward<UTuple>(u)))> равно true для всех i.

14) Для всех i присваивает std::get<i>(std::forward<UTuple>(u)) значению std::get<i>(*this).

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

• std::same_as<std::remove_cvref_t<UTuple>, std::tuple> равно false,
• std::remove_cvref_t<UTuple> не является специализацией std::ranges::subrange,
• sizeof...(Types) равно std::tuple_size_v<std::remove_cvref_t<UTuple>>, и
• std::is_assignable_v<const Ti&, decltype(std::get<i>(std::forward<UTuple>(u)))> равно true для всех i.

Параметры

other	—	tuple, чтобы заменить содержимое этого tuple
p	—	pair, чтобы заменить содержимое этого 2-tuple
u	—	объект tuple-like для замены содержимого этого кортежа

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

*this

Исключения

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

3)

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

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

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

Пример

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

#include <iostream>
#include <string>
#include <string_view>
#include <tuple>
#include <utility>
#include <vector>

// вспомогательная функция для печати std::vector<int>
std::ostream& operator<<(std::ostream& os, std::vector<int> const& v)
{
    os << '{';
    for (std::size_t t = 0; t != v.size(); ++t)
        os << v[t] << (t + 1 < v.size() ? ", " : "");
    return os << '}';
}

// помощники для печати кортежа любого размера
template<class... Args>
void print_tuple(std::string_view name, const std::tuple<Args...>& t)
{
    std::cout << name << " = {";
    std::apply([&](auto&& arg, auto&&... args)
    {
        std::cout << arg;
        ((std::cout << ", " << args), ...);
    }, t);
    std::cout << '}';
}

template<class Tuple1, class Tuple2>
void print_tuples(std::string_view name1, const Tuple1& t1,
                  std::string_view name2, const Tuple2& t2)
{
    print_tuple(name1, t1);
    std::cout << ", ";
    print_tuple(name2, std::tuple(t2));
    std::cout << "\n\n";
    
    for (int i = 0; i < 60; i++)
        std::cout << "─";
    std::cout << '\n';
}

int main()
{
    // Примеры кортеж в кортеж //
    std::tuple<int, std::string, std::vector<int>>
        t1{1, "alpha", {1, 2, 3}},
        t2{2, "beta", {4, 5}};
    print_tuples("1) t1", t1, "t2", t2);
    
    // Обычное присваивание копированием
    // operator=( const tuple& other );
    t1 = t2;
    print_tuples("2) t1 = t2;\n   t1", t1, "t2", t2);
    
    // Обычное присваивание перемещением
    // operator=( tuple&& other );
    t1 = std::move(t2);
    print_tuples("3) t1 = std::move(t2);\n   t1", t1, "t2", t2);
    
    // Преобразующее присваивание копированием
    // operator=( const tuple<UTypes...>& other );
    std::tuple<short, const char*, std::vector<int>> t3{3, "gamma", {6, 7, 8}};
    t1 = t3;
    print_tuples("4) t1 = t3;\n   t1", t1, "t3", t3);
    
    // Преобразующее присваивание перемещением
    // operator=( tuple<UTypes...>&& other );
    t1 = std::move(t3);
    print_tuples("5) t1 = std::move(t3);\n   t1", t1, "t3", t3);
    
    // Примеры пары в кортеж //
    std::tuple<std::string, std::vector<int>> t4{"delta", {10, 11, 12}};
    std::pair<const char*, std::vector<int>> p1{"epsilon", {14, 15, 16}};
    print_tuples("6) t4", t4, "p1", p1);
    
    // Преобразующее присваивание копированием из std::pair
    // operator=( const std::pair<U1, U2>& p );
    t4 = p1;
    print_tuples("7) t4 = p1;\n   t4", t4, "p1", p1);
    
    // Преобразующее присваивание перемещением из std::pair
    // operator=( std::pair<U1, U2>&& p );
    t4 = std::move(p1);
    print_tuples("8) t4 = std::move(p1);\n   t4", t4, "p1", p1);
}

Возможный вывод:

1) t1 = {1, alpha, {1, 2, 3}}, t2 = {2, beta, {4, 5}}

2) t1 = t2;
t1 = {2, beta, {4, 5}}, t2 = {2, beta, {4, 5}}

3) t1 = std::move(t2);
t1 = {2, beta, {4, 5}}, t2 = {2, , {}}

4) t1 = t3;
t1 = {3, gamma, {6, 7, 8}}, t3 = {3, gamma, {6, 7, 8}}

5) t1 = std::move(t3);
t1 = {3, gamma, {6, 7, 8}}, t3 = {3, gamma, {}}

6) t4 = {delta, {10, 11, 12}}, p1 = {epsilon, {14, 15, 16}}

7) t4 = p1;
t4 = {epsilon, {14, 15, 16}}, p1 = {epsilon, {14, 15, 16}}

8) t4 = std::move(p1);
t4 = {epsilon, {14, 15, 16}}, p1 = {epsilon, {}}

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

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

Номер	Применён	Поведение в стандарте	Корректное поведение
LWG 2729	C++11	operator= не имеет ограничений и может привести к ненужному неопределённому поведению	ограничен

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

(конструктор)	создаёт новый tuple (public функция-элемент)
operator=	присваивает содержимое (public функция-элемент std::pair)