Kelas integer_sequence

Mewakili urutan bilangan bulat. Dapat digunakan untuk menyimpulkan dan memperluas paket parameter dalam jenis variadik seperti std::tuple<T...> yang diteruskan sebagai argumen ke fungsi.

Sintaks

template <class T, T... Vals>
struct integer_sequence

Parameter

T
Jenis nilai; harus merupakan jenis integral: jenis bilangan bulat bool, char, char16_t, char32_t, wchar_t, atau integer yang ditandatangani atau tidak ditandatangani.

Katup
Paket parameter non-jenis yang mewakili urutan nilai jenis integral T.

Anggota

Nama	Deskripsi
static size_t size() noexcept	Jumlah elemen dalam urutan.
typedef T value_type	Jenis setiap elemen dalam urutan. Harus merupakan jenis integral.

Keterangan

Paket parameter yang diteruskan langsung ke fungsi dapat dibongkah tanpa pembantu pustaka khusus. Ketika paket parameter adalah bagian dari jenis yang diteruskan ke fungsi, dan Anda memerlukan indeks untuk mengakses elemen, maka cara termudah untuk membonggarnya adalah dengan menggunakan integer_sequence dan jenis terkait alias make_integer_sequence, , index_sequence, make_index_sequencedan index_sequence_for.

Contoh

Contoh berikut didasarkan pada proposal asli N3658. Ini menunjukkan cara menggunakan integer_sequence untuk membuat std::tuple dari std::array<T,N>, dan cara menggunakan integer_sequence untuk mendapatkan anggota tuple.

a2t Dalam fungsi , adalah index_sequence alias berdasarkan size_t jenis integer_sequence integral. make_index_sequence adalah alias yang pada waktu kompilasi membuat berbasis index_sequence nol dengan jumlah elemen yang sama dengan array yang diteruskan oleh pemanggil. a2t meneruskan index_sequence nilai menurut ke a2t_, di mana ekspresi a[I]... membongkar I, dan kemudian elemen diberi makan yang make_tuple mengonsumsinya sebagai argumen individual. Misalnya, jika urutan berisi tiga elemen, maka make_tuple dipanggil sebagai make_tuple(a[0], a[1], a[2]). Elemen array itu sendiri tentu saja bisa menjadi jenis apa pun.

Fungsi terapkan menerima std::tuple, dan menghasilkan integer_sequence dengan menggunakan kelas pembantu tuple_size . Perhatikan bahwa std::d ecay_t diperlukan karena tuple_size tidak berfungsi dengan jenis referensi. Fungsi membongkar apply_ anggota tuple dan meneruskannya sebagai argumen terpisah ke panggilan fungsi. Dalam contoh ini fungsi adalah ekspresi lambda sederhana yang mencetak nilai.

#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;
}

Untuk membuat index_sequence untuk paket parameter, gunakan index_sequence_for<T ...> yang merupakan alias untuk make_index_sequence<ukuran ... (T)>

Persyaratan

Header: <type_traits>

Kumpulan nama XML: std

Lihat juga

Templat Elipsis dan Variadik