22 General utilities library [utilities]

22.4 Tuples [tuple]

22.4.4 Class template tuple [tuple.tuple]

22.4.4.2 Assignment [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.

🔗

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

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

Returns: *this.

Remarks: This operator is defined as deleted unless is_copy_assignable_v<

T_{i}

> is true for all i.

🔗

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

Constraints: (is_copy_assignable_v<const Types> && ...) is true.

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

Returns: *this.

🔗

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

Constraints: is_move_assignable_v<

T_{i}

> is true for all i.

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

T_{i}

>(get(u)) to get(*this).

Returns: *this.

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.

🔗

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

Constraints: (is_assignable_v<const Types&, Types> && ...) is true.

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

_{i}

>(get(u)) to get(*this).

Returns: *this.

🔗

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

Constraints:

(15.1)
sizeof...(Types) equals sizeof...(UTypes) and
(15.2)
is_assignable_v< $T_{i}$ &, const $U_{i}$ &> is true for all i.

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;

Constraints:

(18.1)
sizeof...(Types) equals sizeof...(UTypes) and
(18.2)
(is_assignable_v<const Types&, const UTypes&> && ...) is true.

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

Returns: *this.

🔗

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

Constraints:

(21.1)
sizeof...(Types) equals sizeof...(UTypes) and
(21.2)
is_assignable_v< $T_{i}$ &, $U_{i}$ > is true for all i.

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

U_{i}

>(get(u)) to get(*this).

Returns: *this.

🔗

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

Constraints:

(24.1)
sizeof...(Types) equals sizeof...(UTypes) and
(24.2)
(is_assignable_v<const Types&, UTypes> && ...) is true.

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

_{i}

>(get(u)) to get(*this).

Returns: *this.

🔗

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

Constraints:

(27.1)
sizeof...(Types) is 2 and
(27.2)
is_assignable_v< $T_{0}$ &, const U1&> is true, and
(27.3)
is_assignable_v< $T_{1}$ &, const U2&> is true.

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;

Constraints:

(30.1)
sizeof...(Types) is 2,
(30.2)
is_assignable_v<const $T_{0}$ &, const U1&> is true, and
(30.3)
is_assignable_v<const $T_{1}$ &, const U2&> is true.

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);

Constraints:

(33.1)
sizeof...(Types) is 2 and
(33.2)
is_assignable_v< $T_{0}$ &, U1> is true, and
(33.3)
is_assignable_v< $T_{1}$ &, U2> is true.

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;

Constraints:

(36.1)
sizeof...(Types) is 2,
(36.2)
is_assignable_v<const $T_{0}$ &, U1> is true, and
(36.3)
is_assignable_v<const $T_{1}$ &, U2> is true.

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

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

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.

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.

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

Returns: *this.