C++ integer_sequence

#include <tuple>
#include <iostream>
#include <utility>

template<typename F, typename T, std::size_t... I>
decltype(auto) apply_impl(F f, const T& t, std::index_sequence<I...>)
{
  return f(std::get<I>(t)...);
}

template<typename F, typename T>
decltype(auto) apply(F f, const T& t)
{
    return apply_impl(f, t, std::make_index_sequence<std::tuple_size<T>::value>());
}


int main()
{
  auto tp = std::make_tuple(1, 'A', 1.2);
    
  auto ld = [](int arg1, char arg2, double arg3)->int{
      std::cout << "call func(" << arg1 << ", " << arg2 << ", " << arg3 << ")" << std::endl;
      return 0;
  };  
    
  int ret= apply(ld, tp);
}

參考：https://blog.poxiao.me/p/unpacking-a-tuple-to-call-a-function-in-cpp14/

這里需要注意的是，函數的模板參數推演。C++03/98時，是單個實參，推導出單個模板類型，例如t推導出T。C++11/14開始，參數包也能推導了，例如：

template<int... Is>
struct sequence{};

template<int... Is>
void foo( sequence<Is...> sq )
{
    (std::cout << ... << Is);
}

int main()
{
    foo( sequence<1,3,5,7,9>() );
}

 既然interger_sequence這樣重要，這里給出一個實現。

#include <iostream>

// This is the type which holds sequences
template <int ... Ns> struct sequence {};

// First define the template signature
template <int ... Ns> struct seq_gen;

// Recursion case
template <int I, int ... Ns>
struct seq_gen<I, Ns...>
{
    // Take front most number of sequence,
    // decrement it, and prepend it twice.
    // First I - 1 goes into the counter,
    // Second I - 1 goes into the sequence.
    using type = typename seq_gen<
        I - 1, I - 1 , Ns...>::type;
};

// Recursion abort
template <int ... Ns>
struct seq_gen<0, Ns...>
{
    using type = sequence<Ns...>;
};

template <int N>
using sequence_t = typename seq_gen<N>::type;


template<int...Is>
void show( sequence<Is...>){
    ( ((std::cout << " ") << Is) , ...) ;
}

int main(){
    show( sequence_t<10>() );
}

參考：https://blog.galowicz.de/2016/06/24/integer_sequences_at_compile_time/

原理解析：

sequence_t<10>類型是這個類型的別名：seq_gen<10>::type   見第29行
seq_gen<10>唯一能匹配的模板特化為：seq_gen<10, int...Ns> 。現在這個Ns是空列表{}。這是1個模板參數變成2組模板參數質的飛躍。我們用偽代碼seq_gen<10, {}>表示
seq_gen<10, {}>::type 等價於seq_gen<10-1,10-1, {}>::type即seq_gen<9，9, {}>::type 見第18行
seq_gen<9，9, {}>唯一能匹配的模板特化為：seq_gen<9, int...Ns>。現在這個Ns是列表{9}。我們用偽代碼seq_gen<9, {9}>表示.
seq_gen<9, {9}>::type 等價於seq_gen<9-1,9-1, {9}>::type即seq_gen<8，8, {9}>::type
seq_gen<8，8, {9}>唯一能匹配的模板特化為：seq_gen<8, int...Ns>。現在這個Ns是列表{8,9}。我們用偽代碼seq_gen<8, {8,9}>表示.
......
seq_gen<0, {0,1,2,3,4,5,6,7,8,9}>唯一能匹配的模板特化為第22行，遞歸終結特化。
seq_gen<0, int...Ns>:::type等價於sequence<0,1,2,3,4,5,6,7,8,9>. 結束。

還有更具有效率的算法，有空可研究：https://stackoverflow.com/questions/17424477/implementation-c14-make-integer-sequence