std::tuple<Types...>::演算子=

 

C++

コンパイラサポート

フリースタンディングとホスト

言語

標準ライブラリ

標準ライブラリヘッダー

名前付き要件

機能テストマクロ (C++20)

言語サポートライブラリ

コンセプトライブラリ (C++20)

診断ライブラリ

メモリ管理ライブラリ

メタプログラミングライブラリ (C++11)

汎用ユーティリティライブラリ

コンテナライブラリ

イテレータライブラリ

Rangesライブラリ (C++20)

アルゴリズムライブラリ

文字列ライブラリ

テキスト処理ライブラリ

数値ライブラリ

日付と時刻ライブラリ

入出力ライブラリ

ファイルシステムライブラリ (C++17)

並行サポートライブラリ (C++11)

実行制御ライブラリ (C++26)

Technical specifications (技術仕様)

シンボルインデックス

外部ライブラリ

 

ユーティリティライブラリ

言語サポート 型のサポート (基本型、RTTI) ライブラリ機能検査マクロ (C++20) プログラムユーティリティ 可変引数関数 initializer_list (C++11) is_constant_evaluated (C++20) is_within_lifetime (C++26) source_location (C++20) コルーチンサポート (C++20) 契約サポート (C++26) 三方比較 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_ltis_lteq (C++20)(C++20)(C++20)   is_neqis_gtis_gteq (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)

 

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)

swap(std::tuple)

get(std::tuple)

ヘルパーコンセプト

tuple-like (C++23)

ヘルパークラス

tuple_size<std::tuple>

tuple_element<std::tuple>

uses_allocator<std::tuple>

basic_common_reference<std::tuple> (C++23)

common_type<std::tuple> (C++23)

formatter<std::tuple> (C++23)

ignore

推論ガイド(C++17)

 

tuple& operator=( const tuple& other );	(1)	(C++11以降) (C++20 以降 constexpr)
constexpr const tuple& operator=( const tuple& other ) const;	(2)	(C++23から)
tuple& operator=( tuple&& other ) noexcept(/* see below */);	(3)	(C++11以降) (C++20 以降 constexpr)
constexpr const tuple& operator=( tuple&& other ) const;	(4)	(C++23から)
template< class... UTypes > tuple& operator=( const tuple<UTypes...>& other );	(5)	(C++11以降) (C++20 以降 constexpr)
template< class... UTypes > constexpr const tuple& operator=( const tuple<UTypes...>& other ) const;	(6)	(C++23から)
template< class... UTypes > tuple& operator=( tuple<UTypes...>&& other );	(7)	(C++11以降) (C++20 以降 constexpr)
template< class... UTypes > constexpr const tuple& operator=( tuple<UTypes...>&& other ) const;	(8)	(C++23から)
template< class E1, class E2 > tuple& operator=( const std::pair<E1, E2>& p );	(9)	(C++11以降) (C++20 以降 constexpr)
template< class E1, class E2 > constexpr const tuple& operator=( const std::pair<E1, E2>& p ) const;	(10)	(C++23から)
template< class E1, class E2 > tuple& operator=( std::pair<E1, E2>&& p );	(11)	(C++11以降) (C++20 以降 constexpr)
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から)

タプルの内容を別のタプルライクなオブジェクトの内容で置き換えます。

以下では、

• i は順番に [​0​, sizeof...(Types)) の範囲にあり、
• Ti はクラステンプレートパラメータパック Types の i 番目の型、そして
• Ui は名前が UTypes である関数テンプレートパラメータパックの i 番目の型、

ここでインデックスはゼロベースです。

1) コピー代入演算子。other の各要素を `*this` の対応する要素に代入します。

このオーバーロードは、すべての Ti に対して std::is_copy_assignable<Ti>::value が true である場合を除き、削除済みとして定義されます。

2) const 修飾されたオペランドに対するコピー代入演算子。other の各要素を `*this` の対応する要素に代入します。

このオーバーロードは、すべての Ti に対して std::is_copy_assignable_v<const Ti> が true である場合にのみ、オーバーロード解決に参加します。

3) ムーブ代入演算子。すべての i について、 `std::get(other)` を `std::forward()` したものを `std::get(*this)` に代入します。

このオーバーロードは、すべての Ti に対して std::is_move_assignable<Ti>::value が true である場合にのみ、オーバーロード解決に参加します。

4) const 修飾されたオペランドに対するムーブ代入演算子。すべての i について、 `std::get(other)` を `std::forward()` したものを `std::get(*this)` に代入します。

このオーバーロードは、すべての Ti に対して std::is_assignable_v<const Ti&, Ti> が true である場合にのみ、オーバーロード解決に参加します。

5) すべての i について、 `other` の i 番目の要素を `*this` の i 番目の要素に代入します。

このオーバーロードは、`sizeof...(Types) == sizeof...(UTypes)` であり、すべての対応する型のペア Ti および Ui に対して std::is_assignable<Ti&, const Ui&>::value が true である場合にのみ、オーバーロード解決に参加します。

6) すべての i について、 `other` の i 番目の要素を `*this` の i 番目の要素に代入します。

このオーバーロードは、`sizeof...(Types) == sizeof...(UTypes)` であり、すべての対応する型のペア Ti および Ui に対して std::is_assignable_v<const Ti&, const Ui&> が true である場合にのみ、オーバーロード解決に参加します。

7) すべての i について、 `std::get(other)` を `std::forward()` したものを `std::get(*this)` に代入します。

このオーバーロードは、`sizeof...(Types) == sizeof...(UTypes)` であり、すべての対応する型のペア Ti および Ui に対して std::is_assignable<Ti&, Ui>::value が true である場合にのみ、オーバーロード解決に参加します。

8) すべての i について、 `std::get(other)` を `std::forward()` したものを `std::get(*this)` に代入します。

このオーバーロードは、`sizeof...(Types) == sizeof...(UTypes)` であり、すべての対応する型のペア Ti および Ui に対して std::is_assignable_v<const Ti&, Ui> が true である場合にのみ、オーバーロード解決に参加します。

9) `p.first` を `*this` の最初の要素に、`p.second` を `*this` の2番目の要素に代入します。

このオーバーロードは、

• sizeof...(Types) == 2,
• T0& および `const E1&` に対する std::is_assignable<T0&, const E1&>::value が true であり、
• T1& および `const E2&` に対する std::is_assignable<T1&, const E2&>::value が true である場合にのみ、オーバーロード解決に参加します。

10) `p.first` を最初の要素に、`p.second` を2番目の要素に代入します。

このオーバーロードは、

• sizeof...(Types) == 2,
• `const T0&` および `const E1&` に対する std::is_assignable_v<const T0&, const E1&> が true であり、
• `const T1&` および `const E2&` に対する std::is_assignable_v<const T1&, const E2&> が true である場合にのみ、オーバーロード解決に参加します。

11) `p.first` を `std::forward()` したものを `*this` の最初の要素に、`p.second` を `std::forward()` したものを `*this` の2番目の要素に代入します。

このオーバーロードは、

• sizeof...(Types) == 2,
• `T0&` および `E1` に対する std::is_assignable_v<T0&, E1> が true であり、
• `T1&` および `E2` に対する std::is_assignable_v<T1&, E2> が true である場合にのみ、オーバーロード解決に参加します。

12) `p.first` を `std::forward()` したものを最初の要素に、`p.second` を `std::forward()` したものを2番目の要素に代入します。

このオーバーロードは、

• sizeof...(Types) == 2,
• `const T0&` および `E1` に対する std::is_assignable_v<const T0&, E1> が true であり、
• `const T1&` および `E2` に対する std::is_assignable_v<const T1&, E2> が true である場合にのみ、オーバーロード解決に参加します。

13) すべての i について、 `std::get(std::forward(u))` を `std::get(*this)` に代入します。

このオーバーロードは、

• `std::remove_cvref_t` と `std::tuple` が std::same_as<std::remove_cvref_t<UTuple>, std::tuple> であることは false であり、
• `std::remove_cvref_t` は `std::ranges::subrange` の特殊化ではなく、
• `sizeof...(Types)` が `std::tuple_size_v>` と等しく、
• すべての i について、 `Ti&` と `decltype(std::get(std::forward(u)))` に対する std::is_assignable_v<Ti&, decltype(std::get<i>(std::forward<UTuple>(u)))> が true である場合にのみ、オーバーロード解決に参加します。

14) すべての i について、 `std::get(std::forward(u))` を `std::get(*this)` に代入します。

このオーバーロードは、

• `std::remove_cvref_t` と `std::tuple` が std::same_as<std::remove_cvref_t<UTuple>, std::tuple> であることは false であり、
• `std::remove_cvref_t` は `std::ranges::subrange` の特殊化ではなく、
• `sizeof...(Types)` が `std::tuple_size_v>` と等しく、
• すべての i について、 `const Ti&` と `decltype(std::get(std::forward(u)))` に対する std::is_assignable_v<const Ti&, decltype(std::get<i>(std::forward<UTuple>(u)))> が true である場合にのみ、オーバーロード解決に参加します。

パラメータ

その他	-	このタプルの内容を置き換えるタプル
p	-	この2要素タプルの内容を置き換えるペア
u	-	このタプルの内容を置き換えるタプルライクなオブジェクト

戻り値

*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>
 
// helper function to print 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 << '}';
}
 
// helpers to print a tuple of any size
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";
}
 
int main()
{
    // Tuple to tuple examples //
    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);
 
    // Normal copy assignment
    // operator=( const tuple& other );
    t1 = t2;
    print_tuples("2) t1 = t2;\n   t1", t1, "t2", t2);
 
    // Normal move assignment
    // operator=( tuple&& other );
    t1 = std::move(t2);
    print_tuples("3) t1 = std::move(t2);\n   t1", t1, "t2", t2);
 
    // Converting copy assignment
    // 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);
 
    // Converting move assignment
    // operator=( tuple<UTypes...>&& other );
    t1 = std::move(t3);
    print_tuples("5) t1 = std::move(t3);\n   t1", t1, "t3", t3);
 
    // Pair to tuple examples //
    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);
 
    // Converting copy assignment from std::pair
    // operator=( const std::pair<U1, U2>& p );
    t4 = p1;
    print_tuples("7) t4 = p1;\n   t4", t4, "p1", p1);
 
    // Converting move assignment from 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++標準に遡って適用されました。

DR	適用対象	公開された動作	正しい動作
LWG 2729	C++11	operator= は制約がなく、 不必要な未定義動作を引き起こす可能性がありました。	制約付き

関連項目

(コンストラクタ)	新しい tuple を構築する (public メンバ関数)
operator=	内容を代入する (std::pair<T1,T2> の public メンバ関数)