C++
std :: integer_sequence

소개

std :: tuple을 돌린다. 기능 매개 변수로

std::tuple<T...> 는 여러 값을 전달하는 데 사용될 수 있습니다. 예를 들어, 일련의 매개 변수를 대기열의 일부 양식에 저장하는 데 사용할 수 있습니다. 이러한 튜플을 처리 할 때 요소를 함수 호출 인수로 변환해야합니다.

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

클래스가 std::get<I>(object) 및 std::tuple_size<T>::value 하는 한 그것은 위의 process() 함수로 확장 될 수 있습니다. 함수 자체는 인수의 수와 완전히 독립적입니다.

정수로 구성된 매개 변수 팩 만들기

std::integer_sequence 자체는 매개 변수 팩으로 변환 될 수있는 정수 시퀀스를 보유하는 것입니다. 주요한 가치는 이러한 시퀀스를 생성하는 "팩토리"클래스 템플릿을 생성 할 수 있다는 것입니다.

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

print_sequence() 함수 템플릿은 정수 순서를 확장 할 때 std::initializer_list<bool> 사용하여 평가 순서를 보장하고 사용되지 않는 [배열] 변수를 생성하지 않습니다.

일련의 색인을 요소의 사본으로 변환

값으로 쉼표 표현식에서 인덱스의 매개 변수 팩을 확장하면 각 인덱스에 대한 값의 복사본이 만들어집니다. 안타깝게도 gcc 와 clang 은 인덱스가 효과가 없다고 생각하고 경고합니다 ( gcc 는 인덱스를 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";
}