23 General utilities library [utilities]

Effects: Значение инициализирует каждый элемент.

Remarks: Этот конструктор не должен участвовать в разрешении перегрузки, кроме случаев, когда он is_­default_­constructible_­v<${\text{T}}_i$> предназначен true для всех i. [  Note: Это поведение может быть реализовано с помощью шаблона конструктора с аргументами шаблона по умолчанию. ] Конструктор является явным тогда и только тогда, когда он не может быть неявно сконструирован по умолчанию хотя бы для одного . [ Это поведение может быть реализовано с помощью трейта, который проверяет, можно ли инициализировать с помощью . ]  — end note  ${\text{T}}_i$ i Note: const ${\text{T}}_i$& {}  — end note 

Effects: Инициализирует каждый элемент значением соответствующего параметра.

Remarks: Этот конструктор не должен участвовать в разрешении перегрузки , если sizeof...(Types) >= 1 и is_­copy_­constructible_­v<${\text{T}}_i$> не true для всех i. Конструктор является явным тогда и только тогда, когда is_­convertible_­v<const ${\text{T}}_i$&, ${\text{T}}_i$> он false предназначен хотя бы для одного i.

Effects: Инициализирует элементы в кортеже с соответствующим значением в std​::​forward<UTypes>(u).

Remarks: Этот конструктор не должен участвовать в разрешении перегрузки , если sizeof...(Types) == sizeof...(UTypes) и sizeof...(Types) >= 1 и is_­constructible_­v<${\text{T}}_i$, ${\text{U}}_i$&&> является true для всех i. Конструктор является явным тогда и только тогда, когда is_­convertible_­v<${\text{U}}_i$&&, ${\text{T}}_i$> он false предназначен хотя бы для одного i.

Requires: is_­copy_­constructible_­v<${\text{T}}_i$> это true для всех i.

Effects: Инициализирует каждый элемент *this соответствующего элемента u.

Requires: is_­move_­constructible_­v<${\text{T}}_i$> это true для всех i.

Effects: Для всех iинициализирует $i^{\text{th}}$ элемент *this with std​::​forward<${\text{T}}_i$>(get<i>(u)).

Effects: Инициализирует каждый элемент *this соответствующего элемента u.

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

• (16.1)

  sizeof...(Types) == sizeof...(UTypes) а также

• (16.2)

  is_­constructible_­v<${\text{T}}_i$, const ${\text{U}}_i$&> это true для всех i, и

• (16.3)

  sizeof...(Types) != 1, или (когда Types... расширяется до T и UTypes... расширяется до U)
  !is_­convertible_­v<const tuple<U>&, T> && !is_­constructible_­v<T, const tuple<U>&>
  && !is_­same_­v<T, U> равно true.

Конструктор является явным тогда и только тогда, когда is_­convertible_­v<const ${\text{U}}_i$&, ${\text{T}}_i$> он false предназначен хотя бы для одного i.

Effects: Для всех iинициализирует $i^{\text{th}}$ элемент *this with std​::​forward<${\text{U}}_i$>(get<i>(u)).

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

• (18.1)

  sizeof...(Types) == sizeof...(UTypes), а также

• (18.2)

  is_­constructible_­v<${\text{T}}_i$, ${\text{U}}_i$&&> это true для всех i, и

• (18.3)

  sizeof...(Types) != 1, или (когда Types... расширяется до T и UTypes... расширяется до U)
  !is_­convertible_­v<tuple<U>, T> && !is_­constructible_­v<T, tuple<U>> &&
  !is_­same_­v<T, U> равно true.

Конструктор является явным тогда и только тогда, когда is_­convertible_­v<${\text{U}}_i$&&, ${\text{T}}_i$> он false предназначен хотя бы для одного i.

Effects: Инициализирует первый элемент с помощью, u.first а второй элемент с помощью u.second.

Remarks: Этот конструктор не должен участвовать в разрешении перегрузки, за исключением случаев sizeof...(Types) == 2, когда is_­constructible_­v<${\text{T}}_0$, const U1&> есть true и is_­constructible_­v<${\text{T}}_1$, const U2&> есть true.

Конструктор является явным тогда и только тогда, когда is_­convertible_­v<const U1&, ${\text{T}}_0$> есть false или is_­convertible_­v<const U2&, ${\text{T}}_1$> есть false.

Effects: Инициализирует первый элемент с помощью, std​::​forward<U1>(u.first) а второй элемент с помощью std​::​forward<U2>(u.second).

Remarks: Этот конструктор не должен участвовать в разрешении перегрузки, за исключением случаев sizeof...(Types) == 2, когда is_­constructible_­v<${\text{T}}_0$, U1&&> есть true и is_­constructible_­v<${\text{T}}_1$, U2&&> есть true.

Конструктор является явным тогда и только тогда, когда is_­convertible_­v<U1&&, ${\text{T}}_0$> есть false или is_­convertible_­v<U2&&, ${\text{T}}_1$> есть false.

Requires: Alloc должны соответствовать требованиям для Allocator.

Effects: Эквивалентен предыдущим конструкторам, за исключением того, что каждый элемент построен с использованием uses-allocator construction.

Effects: Присваивает каждый элемент u к соответствующему элементу *this.

Remarks: Этот оператор должен быть определен как удаленный, если он не is_­copy_­assignable_­v<${\text{T}}_i$> предназначен true для всех i.

Returns: *this.

Effects: Для всех i, назначает std​::​forward<${\text{T}}_i$>(get<i>(u)) на get<i>(*this).

Remarks: Этот оператор должен быть определен как удаленный, если он не is_­move_­assignable_­v<${\text{T}}_i$> предназначен true для всех i.

Remarks: Выражение внутри noexcept эквивалентно логическому и следующих выражений:

is_nothrow_move_assignable_v<$T_i$>

где $T_i$ это $i^{\text{th}}$ тип в Types.

Returns: *this.

Effects: Присваивает каждый элемент u к соответствующему элементу *this.

Remarks: Этот оператор не должен участвовать в разрешении перегрузки , если sizeof...(Types) == sizeof...(UTypes) и is_­assignable_­v<${\text{T}}_i$&, const ${\text{U}}_i$&> не true для всех i.

Returns: *this.

Effects: Для всех i, назначает std​::​forward<${\text{U}}_i$>(get<i>(u)) на get<i>(*this).

Remarks: Этот оператор не должен участвовать в разрешении перегрузки, кроме как is_­assignable_­v<${\text{T}}_i$&, ${\text{U}}_i$&&> == true для всех i и sizeof...(Types) == sizeof...(UTypes).

Returns: *this.

Effects: Присваивается u.first первому элементу *this и u.second второму элементу *this.

Remarks: Этот оператор не должен участвовать в разрешении перегрузки , если sizeof...(Types) == 2 и is_­assignable_­v<${\text{T}}_0$&, const U1&> не true для первого типа ${\text{T}}_0$ в Types и is_­assignable_­v<${\text{T}}_1$&, const U2&> является true для второго типа ${\text{T}}_1$ в Types.

Returns: *this.

Effects: Присваивается std​::​forward<U1>(u.first) первому элементу *this и
std​::​forward<U2>(u.second) второму элементу *this.

Remarks: Этот оператор не должен участвовать в разрешении перегрузки , если sizeof...(Types) == 2 и is_­assignable_­v<${\text{T}}_0$&, U1&&> не true для первого типа ${\text{T}}_0$ в Types и is_­assignable_­v<${\text{T}}_1$&, U2&&> является true для второго типа ${\text{T}}_1$ в Types.

Returns: *this.

Requires: Каждый элемент в *this должен быть заменен на ([swappable.requirements]) соответствующий элемент в rhs.

Effects: Вызывает swap каждый элемент в *this и соответствующий ему элемент в rhs.

Remarks: Выражение внутри noexcept эквивалентно логическому и следующих выражений:

is_nothrow_swappable_v<$T_i$>

где $T_i$ это $i^{\text{th}}$ тип в Types.

Throws: Ничего, если один из поэлементных swap вызовов не вызовет исключение.

Пакет VTypes определяется следующим образом. Пусть U${}_i$ будет decay_­t<T${}_i$> для каждого T${}_i$ в TTypes. Если U${}_i$ - это специализация reference_­wrapper, то V${}_i$ в VTypes - U${}_i$​::​type&, иначе V${}_i$ - U${}_i$.

Returns: tuple<VTypes...>(std​::​forward<TTypes>(t)...).

[ Example:

int i; float j;
make_tuple(1, ref(i), cref(j))

создает кортеж типа tuple<int, int&, const float&>. ]  — end example 

Effects: Создает кортеж ссылок на аргументы, t пригодный для пересылки в качестве аргументов функции. Поскольку результат может содержать ссылки на временные переменные, программа должна гарантировать, что возвращаемое значение этой функции не переживет ни один из ее аргументов (например, программа обычно не должна сохранять результат в именованной переменной).

Returns: tuple<TTypes&&...>(std​::​forward<TTypes>(t)...).

Returns: tuple<TTypes&...>(t...). Когда аргумент в t is ignore, присвоение любого значения соответствующему элементу кортежа не имеет никакого эффекта.

[  Example: tie функции позволяют создавать кортежи, которые распаковывают кортежи в переменные. ignore можно использовать для элементов, которые не нужны:

int i; std::string s;
tie(i, ignore, s) = make_tuple(42, 3.14, "C++");
// i == 42, s == "C++"

 — end example ]

В следующих параграфах пусть ${\text{T}}_i$ будет $i^{\text{th}}$ типом Tuples, ${\text{U}}_i$ быть remove_­reference_­t<T${}_i$>и ${\text{tp}}_i$ будет $i^{\text{th}}$ параметром в пакете параметров функции tpls, где все индексации отсчитываются от нуля.

Requires: Для всех i, ${\text{U}}_i$ должен быть тип ${\text{cv}}_i$ tuple<${\text{Args}}_i$...>, где ${\text{cv}}_i$ это (возможно , пустой) и является параметром пакет , представляющий типы элементов в . Позвольте быть типом в . Для всех должны быть выполнены следующие требования: $i^{\text{th}}$ cv-qualifier-seq ${\text{Args}}_i$ ${\text{U}}_i$ ${\text{A}}_{ik}$ $k^{\text{th}}$ ${\text{Args}}_i$${\text{A}}_{ik}$

• (10.1)

  Если ${\text{T}}_i$ выводится как ссылочный тип lvalue, то в is_­constructible_­v<${\text{A}}_{ik}$, $c{v}_i{\text{A}}_{ik}$&> == trueпротивном случае

• (10.2)

  is_­constructible_­v<${\text{A}}_{ik}$, $c{v}_i{\text{A}}_{ik}$&&> == true.

Remarks: Типы в CTypes должны быть равны упорядоченной последовательности расширенных типов ${\text{Args}}_0$..., ${\text{Args}}_1$..., …, ${\text{Args}}_{n-1}$..., где n равно sizeof...(Tuples). Позвольте ${\text{e}}_i$... быть $i^{\text{th}}$ упорядоченной последовательностью элементов кортежа результирующего tuple объекта, соответствующей последовательности типов ${\text{Args}}_i$.

Returns: tuple Объект , построенный по инициализации ${k_i}^{\text{th}}$ элемента типа ${\text{e}}_{ik}$ в ${\text{e}}_i$... с

get<$k_i$>(std::forward<${\text{T}}_i$>(${\text{tp}}_i$))

для каждой действующей $k_i$ и каждой группы ${\text{e}}_i$ по порядку.

[  Note: Реализация может поддерживать дополнительные типы в пакете параметров, Tuples которые поддерживают tuple-подобный протокол, такие как pair и array. ]  — end note 

Effects: Учитывая функцию только для экспозиции:

template <class F, class Tuple, size_t... I>
constexpr decltype(auto)
    apply_impl(F&& f, Tuple&& t, index_sequence<I...>) {                // exposition only
  return INVOKE(std::forward<F>(f), std::get<I>(std::forward<Tuple>(t))...);
}

Эквивалентен:

return apply_impl(std::forward<F>(f), std::forward<Tuple>(t),
                  make_index_sequence<tuple_size_v<decay_t<Tuple>>>{});

Effects: Учитывая функцию только для экспозиции:

template <class T, class Tuple, size_t... I>
constexpr T make_from_tuple_impl(Tuple&& t, index_sequence<I...>) {     // exposition only
  return T(get<I>(std::forward<Tuple>(t))...);
}

Эквивалентен:

return make_from_tuple_impl<T>(forward<Tuple>(t),
                               make_index_sequence<tuple_size_v<decay_t<Tuple>>>{});

[  Note: Тип T должен быть указан как явный параметр шаблона, так как он не может быть выведен из списка аргументов. ]  — end note 

Remarks: Все специализации tuple_­size должны соответствовать UnaryTypeTrait требованиям с базовой характеристикой integral_­constant<size_­t, N> для некоторых N.

Requires: I < sizeof...(Types). Программа некорректно сформирована, если I выходит за пределы допустимого диапазона.

Type: TI - это тип Ith элемента Types, в котором индексирование начинается с нуля.

Обозначим TS через tuple_­size<T> - cvнеквалифицированный тип T. Если выражение TS​::​value правильно сформировано, когда рассматривается как неоцененный операнд, то каждый из трех шаблонов должен соответствовать UnaryTypeTrait требованиям с базовой характеристикой

integral_constant<size_t, TS::value>

В противном случае у них не будет ни одного члена value.

Проверка доступа выполняется, как если бы в контексте, не связанном с TS и T. Учитывается только действительность непосредственного контекста выражения. [  Note: Компиляция выражения может привести к побочным эффектам, таким как создание экземпляров специализаций шаблонов классов и специализаций шаблонов функций, создание неявно определенных функций и т. Д. Такие побочные эффекты не относятся к «непосредственному контексту» и могут привести к неправильному формированию программы. ] — end note 

Помимо того <tuple> , что эти три шаблона доступны через включение заголовка, они доступны либо при включении заголовков, <array> либо <utility> .

Обозначим TE через tuple_­element_­t<I, T> - cvнеквалифицированный тип T. Затем каждый из трех шаблонов должен соответствовать TransformationTrait требованиям с помощью typedef члена, type который называет следующий тип:

• (7.1)

  для первой специализации add_­const_­t<TE>,

• (7.2)

  для второй специализации add_­volatile_­t<TE>, и

• (7.3)

  для третьей специализации add_­cv_­t<TE>.

Помимо того <tuple> , что эти три шаблона доступны через включение заголовка, они доступны либо при включении заголовков, <array> либо <utility> .

Requires: I < sizeof...(Types). Программа некорректно сформирована, если I выходит за пределы допустимого диапазона.

Returns: Ссылка на Ith элемент t, где индексирование начинается с нуля.

[  Note A: Если T in Types - некоторый ссылочный тип X&, возвращаемый тип - X&нет X&&. Однако, если тип элемента не является ссылочным типом T, возвращается тип T&&. ] — end note 

[  Note B: Констанс неглубокий. Если T in Types - некоторый ссылочный тип X&, возвращаемый тип - X&not const X&. Однако, если тип элемента не является ссылочным типом T, возвращается тип const T&. Это согласуется с тем, как константность определяется для работы с переменными-членами ссылочного типа. ]  — end note 

Requires: Тип T встречается ровно один раз Types.... В противном случае программа имеет неверный формат.

Returns: Ссылка на элемент, t соответствующий типу T в Types....

[ Example:

  const tuple<int, const int, double, double> t(1, 2, 3.4, 5.6);
  const int& i1 = get<int>(t);        // OK. Not ambiguous. i1 == 1
  const int& i2 = get<const int>(t);  // OK. Not ambiguous. i2 == 2
  const double& d = get<double>(t);   // ERROR. ill-formed

 — end example ]

Requires: Для всех i, где 0 <= i и i < sizeof...(TTypes), get<i>(t) == get<i>(u) является действительным выражением , возвращающая тип , который конвертируется в bool. sizeof...(TTypes) == sizeof...(UTypes).

Returns: true если get<i>(t) == get<i>(u) для всех i, иначе false. Для любых двух кортежей нулевой длины e и f, e == f возвратов true.

Effects: Элементарные сравнения выполняются в порядке от нулевого индекса вверх. Никакие сравнения или обращения к элементам не выполняются после первого сравнения на равенство, которое оценивается как false.

Requires: Для всех i, where 0 <= i и i < sizeof...(TTypes)оба get<i>(t) < get<i>(u) и get<i>(u) < get<i>(t) являются допустимыми выражениями, возвращающими типы, в которые можно преобразовать bool. sizeof...(TTypes) == sizeof...(UTypes).

Returns: Результат лексикографического сравнения между t и u. Результат определяется как:, (bool)(get<0>(t) < get<0>(u)) || (!(bool)(get<0>(u) < get<0>(t)) && t${}_{tail}$ < u${}_{tail}$)где r${}_{tail}$ для некоторого кортежа r это кортеж, содержащий все элементы, кроме первого r. Для любых двух кортежей нулевой длины e и f, e < f возвратов false.

Returns: !(t == u).

Returns: u < t.

Returns: !(u < t).

Returns: !(t < u).

Requires: Alloc должен быть Allocator.

[  Note: Специализация этого признака сообщает другим компонентам библиотеки, которые tuple могут быть созданы с помощью распределителя, даже если у него нет вложенного allocator_­type. ]  — end note 

Remarks: Эта функция не должна участвовать в разрешении перегрузки, кроме случаев, когда она is_­swappable_­v<${\text{T}}_i$> предназначена true для всех i, где $0\le i<\text{sizeof...(Types)}$. Выражение внутри noexcept эквивалентно:

noexcept(x.swap(y))

Effects: Как будто мимо x.swap(y).