# 23 General utilities library [utilities]

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,

Ti be the

ith type in

Types,
and

Ui be the

ith type in a
template parameter pack named

UTypes, where indexing is zero-based

. ```
tuple& operator=(const tuple& u);
```

Effects: Assigns each element of

u to the corresponding
element of

*this. Remarks: This operator shall be defined as deleted unless

is_copy_assignable_v<Ti> is

true for all

i. ```
tuple& operator=(tuple&& u) noexcept(see below);
```

Effects: For all

i, assigns

std::forward<Ti>(get<i>(u)) to

get<i>(*this). Remarks: This operator shall be defined as deleted unless

is_move_assignable_v<Ti> is

true for all

i. Remarks: The expression inside noexcept is equivalent to the logical and of the
following expressions:

is_nothrow_move_assignable_v<Ti>

where

Ti is the

ith type in

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

Effects: Assigns each element of

u to the corresponding element
of

*this. Remarks: This operator shall not participate in overload resolution unless

sizeof...(Types) == sizeof...(UTypes) and

is_assignable_v<Ti&, const Ui&> is

true for all

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

Effects: For all

i, assigns

std::forward<Ui>(get<i>(u)) to

get<i>(*this). Remarks: This operator shall not participate in overload resolution unless

is_assignable_v<Ti&, Ui&&> == true for all

i and

sizeof...(Types) == sizeof...(UTypes). ```
template <class U1, class U2> 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. Remarks: This operator shall not participate in overload resolution unless

sizeof...(Types) == 2 and

is_assignable_v<T0&, const U1&> is

true for the first type

T0 in

Types and

is_assignable_v<T1&, const U2&> is

true for the
second type

T1 in

Types. ```
template <class U1, class U2> 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. Remarks:
This operator shall not participate in overload resolution unless

sizeof...(Types) == 2 and

is_assignable_v<T0&, U1&&> is

true for the first type

T0 in

Types and

is_assignable_v<T1&, U2&&> is

true for the second
type

T1 in

Types.