integer_sequence (Clase)
Representa una secuencia de enteros. Puede usarse para deducir y expandir paquetes de parámetros en tipos de variádicos como std::tuple<T...> que se pasan como argumentos a una función.
Sintaxis
template <class T, T... Vals>
struct integer_sequence
Parámetros
T
Tipo de los valores; debe ser un tipo integral: bool, char, char16_t, char32_t, wchar_t o tipos enteros con o sin signo.
Vals
Paquete de parámetros sin tipo que representa una secuencia de valores de tipo entero T.
Miembros
| Nombre | Descripción |
|---|---|
static size_t size() noexcept |
Número de elementos de la secuencia. |
typedef T value_type |
Tipo de cada elemento de la secuencia. Debe ser un tipo entero. |
Comentarios
Los paquetes de parámetros que se pasan directamente a una función pueden desempaquetarse sin asistentes de biblioteca especiales. Cuando un paquete de parámetros forma parte de un tipo que se pasa a una función y se necesitan índices para acceder a los elementos, la manera más fácil de descomprimirlo es usar integer_sequence y sus alias de tipo relacionados make_integer_sequence, index_sequence, make_index_sequence y index_sequence_for.
Ejemplo
El siguiente ejemplo se basa en la propuesta original N3658. Muestra cómo usar integer_sequence para crear std::tuple a partir de std::array<T,N> y cómo usar integer_sequence para llegar a los miembros de la tupla.
En la función a2t, index_sequence es un alias de integer_sequence según el tipo entero size_t. make_index_sequence es un alias que, en tiempo de compilación, crea index_sequence de base cero con el mismo número de elementos que la matriz que el llamador pasa. a2t pasa index_sequence por valor a a2t_, donde la expresión a[I]... desempaqueta I y, a continuación, los elementos se suministran a make_tuple, que los consume como argumentos individuales. Por ejemplo, si la secuencia contiene tres elementos, se llama a make_tuple como make_tuple(a[0], a[1], a[2]). Los elementos de matriz pueden ser cualquier tipo.
La función apply acepta std::tuple y genera integer_sequence mediante la clase del asistente tuple_size. Tenga en cuenta que std::decay_t es necesario porque tuple_size no funciona con tipos de referencia. La función apply_ desempaqueta los miembros de la tupla y los reenvía como argumentos independientes a una llamada de función. En este ejemplo, la función es una expresión lambda sencilla que imprime los valores.
#include <stddef.h>
#include <iostream>
#include <tuple>
#include <utility>
#include <array>
#include <string>
using namespace std;
// Create a tuple from the array and the index_sequence
template<typename Array, size_t... I>
auto a2t_(const Array& a, index_sequence<I...>)
{
return make_tuple(a[I]...);
}
// Create an index sequence for the array, and pass it to the
// implementation function a2t_
template<typename T, size_t N>
auto a2t(const array<T, N>& a)
{
return a2t_(a, make_index_sequence<N>());
}
// Call function F with the tuple members as separate arguments.
template<typename F, typename Tuple = tuple<T...>, size_t... I>
decltype(auto) apply_(F&& f, Tuple&& args, index_sequence<I...>)
{
return forward<F>(f)(get<I>(forward<Tuple>(args))...);
}
// Create an index_sequence for the tuple, and pass it with the
// function object and the tuple to the implementation function apply_
template<typename F, typename Tuple = tuple<T...>>
decltype(auto) apply(F&& f, Tuple&& args)
{
using Indices = make_index_sequence<tuple_size<decay_t<Tuple>>::value >;
return apply_(forward<F>(f), forward<Tuple>(args), Indices());
}
int main()
{
const array<string, 3> arr { "Hello", "from", "C++14" };
//Create a tuple given a array
auto tup = a2t(arr);
// Extract the tuple elements
apply([](const string& a, const string& b, const string& c) {cout << a << " " << b << " " << c << endl; }, tup);
char c;
cin >> c;
}
Para realizar index_sequence para un paquete de parámetros, use index_sequence_for<T...>, que es un alias para make_index_sequence<sizeof...(T)>.
Requisitos
Encabezado: <type_traits>
Espacio de nombres: std