C++
std :: integer_sequence

Invoering

Draai een std :: tuple in functieparameters

Een std::tuple<T...> kan worden gebruikt om meerdere waarden door te geven. Het kan bijvoorbeeld worden gebruikt om een reeks parameters op te slaan in een vorm van een wachtrij. Bij het verwerken van zo'n tuple moeten de elementen worden omgezet in functie-aanroepargumenten:

#include <array>
#include <iostream>
#include <string>
#include <tuple>
#include <utility>

// ----------------------------------------------------------------------------
// Example functions to be called:
void f(int i, std::string const& s) {
    std::cout << "f(" << i << ", " << s << ")\n";
}
void f(int i, double d, std::string const& s) {
    std::cout << "f(" << i << ", " << d << ", " << s << ")\n";
}
void f(char c, int i, double d, std::string const& s) {
    std::cout << "f(" << c << ", " << i << ", " << d << ", " << s << ")\n";
}
void f(int i, int j, int k) {
    std::cout << "f(" << i << ", " << j << ", " << k << ")\n";
}

// ----------------------------------------------------------------------------
// The actual function expanding the tuple:
template <typename Tuple, std::size_t... I>
void process(Tuple const& tuple, std::index_sequence<I...>) {
    f(std::get<I>(tuple)...);
}

// The interface to call. Sadly, it needs to dispatch to another function
// to deduce the sequence of indices created from std::make_index_sequence<N>
template <typename Tuple>
void process(Tuple const& tuple) {
    process(tuple, std::make_index_sequence<std::tuple_size<Tuple>::value>());
}

// ----------------------------------------------------------------------------
int main() {
    process(std::make_tuple(1, 3.14, std::string("foo")));
    process(std::make_tuple('a', 2, 2.71, std::string("bar")));
    process(std::make_pair(3, std::string("pair")));
    process(std::array<int, 3>{ 1, 2, 3 });
}

Zolang een klasse std::get<I>(object) en std::tuple_size<T>::value , kan deze worden uitgebreid met de functie process() hierboven. De functie zelf is volledig onafhankelijk van het aantal argumenten.

Maak een parameterpakket dat bestaat uit gehele getallen

std::integer_sequence zelf gaat over het vasthouden van een reeks gehele getallen die in een parameterpakket kunnen worden omgezet. De primaire waarde is de mogelijkheid om sjablonen in de "fabrieksklasse" te maken met deze sequenties:

#include <iostream>
#include <initializer_list>
#include <utility>

template <typename T, T... I>
void print_sequence(std::integer_sequence<T, I...>) {
    std::initializer_list<bool>{ bool(std::cout << I << ' ')... };
    std::cout << '\n';
}

template <int Offset, typename T, T... I>
void print_offset_sequence(std::integer_sequence<T, I...>) {
    print_sequence(std::integer_sequence<T, T(I + Offset)...>());
}

int main() {
    // explicitly specify sequences:
    print_sequence(std::integer_sequence<int, 1, 2, 3>());
    print_sequence(std::integer_sequence<char, 'f', 'o', 'o'>());

    // generate sequences:
    print_sequence(std::make_index_sequence<10>());
    print_sequence(std::make_integer_sequence<short, 10>());
    print_offset_sequence<'A'>(std::make_integer_sequence<char, 26>());
}

De functiesjabloon print_sequence() gebruikt een std::initializer_list<bool> bij het uitbreiden van de reeks met gehele getallen om de volgorde van evaluatie te garanderen en geen ongebruikte variabele [array] te maken.

Verander een reeks indices in kopieën van een element

Door het parameterpakket van indices in een komma-expressie uit te breiden met een waarde, wordt een kopie van de waarde voor elk van de indices gemaakt. Helaas denken gcc en clang dat de index geen effect heeft en waarschuwen ervoor ( gcc kan worden uitgeschakeld door de index void ):

#include <algorithm>
#include <array>
#include <iostream>
#include <iterator>
#include <string>
#include <utility>

template <typename T, std::size_t... I>
std::array<T, sizeof...(I)> make_array(T const& value, std::index_sequence<I...>) {
    return std::array<T, sizeof...(I)>{ (I, value)... };
}

template <int N, typename T>
std::array<T, N> make_array(T const& value) {
    return make_array(value, std::make_index_sequence<N>());
}

int main() {
    auto array = make_array<20>(std::string("value"));
    std::copy(array.begin(), array.end(),
              std::ostream_iterator<std::string>(std::cout, " "));
    std::cout << "\n";
}