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

Consulte también

Puntos suspensivos y plantillas variádicas