[tuple.assign]

For each tuple assignment operator, an exception is thrown only if the assignment of one of the types in Types throws an exception.

In the function descriptions that follow, let i be in the range [0, sizeof.(Types)) in order,

T {i be the {i th type in Types, and U {i be the {i th type in a template parameter pack named UTypes, where indexing is zero-based .}^{th type in a template parameter pack named UTypes, where indexing is zero-based .}}_{i be the {i th type in a template parameter pack named UTypes, where indexing is zero-based .}^{th type in a template parameter pack named UTypes, where indexing is zero-based .}}}^{th type in Types, and U {i be the {i th type in a template parameter pack named UTypes, where indexing is zero-based .}^{th type in a template parameter pack named UTypes, where indexing is zero-based .}}_{i be the {i th type in a template parameter pack named UTypes, where indexing is zero-based .}^{th type in a template parameter pack named UTypes, where indexing is zero-based .}}}}_{i be the {i th type in Types, and U {i be the {i th type in a template parameter pack named UTypes, where indexing is zero-based .}^{th type in a template parameter pack named UTypes, where indexing is zero-based .}}_{i be the {i th type in a template parameter pack named UTypes, where indexing is zero-based .}^{th type in a template parameter pack named UTypes, where indexing is zero-based .}}}^{th type in Types, and U {i be the {i th type in a template parameter pack named UTypes, where indexing is zero-based .}^{th type in a template parameter pack named UTypes, where indexing is zero-based .}}_{i be the {i th type in a template parameter pack named UTypes, where indexing is zero-based .}^{th type in a template parameter pack named UTypes, where indexing is zero-based .}}}}

🔗

constexpr tuple& operator=(const tuple& u);

Effects: Assigns each element of u to the corresponding element of *this.

Remarks: This operator is defined as deleted unless is_copy_assignable_v<

T {i > is true for all i .}_{i >}

🔗

constexpr const tuple& operator=(const tuple& u) const;

Returns: *this.

🔗

constexpr tuple& operator=(tuple&& u) noexcept(see below);

Effects: For all i, assigns std::forward<

T {i > (get < i > (u)) to get < i > (* this) .}_{i > (get < i > (u))}

Remarks: The exception specification is equivalent to the logical and of the following expressions: is_nothrow_move_assignable_v<

{T i > where {T i is the {i th type in Types .}^{th type in Types .}}_{i is the {i th type in Types .}^{th type in Types .}}}_{i >}

🔗

constexpr const tuple& operator=(tuple&& u) const;

Effects: For all i, assigns std::forward<T

{i > (get < i > (u)) to get < i > (* this) .}_{i > (get < i > (u))}

Returns: *this.

🔗

template<class. UTypes> constexpr tuple& operator=(const tuple<UTypes..>& u);

Effects: Assigns each element of u to the corresponding element of *this.

Returns: *this.

🔗

template<class. UTypes> constexpr const tuple& operator=(const tuple<UTypes..>& u) const;

Returns: *this.

🔗

template<class. UTypes> constexpr tuple& operator=(tuple<UTypes..>& u);

Effects: For all i, assigns std::forward<

U {i > (get < i > (u)) to get < i > (* this) .}_{i > (get < i > (u))}

Returns: *this.

🔗

template<class. UTypes> constexpr const tuple& operator=(tuple<UTypes..>& u) const;

Effects: For all i, assigns std::forward<U

{i > (get < i > (u)) to get < i > (* this) .}_{i > (get < i > (u))}

Returns: *this.

🔗

template<class U1, class U2> constexpr tuple& operator=(const pair<U1, U2>& u);

Effects: Assigns u.first to the first element of *this and u.second to the second element of *this.

Returns: *this.

🔗

template<class U1, class U2> constexpr const tuple& operator=(const pair<U1, U2>& u) const;

Effects: Assigns u.first to the first element and u.second to the second element.

Returns: *this.

🔗

template<class U1, class U2> constexpr tuple& operator=(pair<U1, U2>& u);

Effects: Assigns std::forward<U1>(u.first) to the first element of *this and

std::forward<U2>(u.second) to the second element of *this.

Returns: *this.

🔗

template<class U1, class U2> constexpr const tuple& operator=(pair<U1, U2>& u) const;

Returns: *this.

🔗

template<tuple-like UTuple>
  constexpr tuple& operator=(UTuple&& u);

Constraints:

(39.1)
different-from<UTuple, tuple> ([range.utility.helpers]) is true,
(39.2)
remove_cvref_t<UTuple> is not a specialization of ranges::subrange,
(39.3)
sizeof.(Types) equals tuple_size_v<remove_cvref_t<UTuple>>, and
(39.4)
is_assignable_v< $T {i &, decltype (get (std :: forward < UTuple > (u)) > is true for all i .}_{i &, decltype (get (std :: forward < UTuple > (u)) >}$

Effects: For all i, assigns get(std::forward<UTuple>(u)) to get(*this).

Returns: *this.

🔗

template<tuple-like UTuple>
  constexpr const tuple& operator=(UTuple&& u) const;

Constraints:

(42.1)
different-from<UTuple, tuple> ([range.utility.helpers]) is true,
(42.2)
remove_cvref_t<UTuple> is not a specialization of ranges::subrange,
(42.3)
sizeof.(Types) equals tuple_size_v<remove_cvref_t<UTuple>>, and
(42.4)
is_assignable_v<const $T {i &, decltype (get (std :: forward < UTuple > (u)) > is true for all i .}_{i &, decltype (get (std :: forward < UTuple > (u)) >}$

Effects: For all i, assigns get(std::forward<UTuple>(u)) to get(*this).

Returns: *this.