C++ 11：使用向量元素調用可變參數函數

Question

關於如何使用元組元素調用可變參數函數有很多問題。 如： How do I expand a tuple into variadic template function's arguments? 我的問題是有點不同：

我有一個家庭的功能：

void f(int arg1); 
void f(int arg1, int arg2); 
... 

我想一個模板：

template<size_t Arity> 
void call(std::vector<int> args) { 
    ??? 
} 

調用適當f與args[0], args[1]...

Answer 1

這裏有一個工作示例：

#include <vector> 

// indices machinery 

template< std::size_t... Ns > 
struct indices { 
    typedef indices< Ns..., sizeof...(Ns) > next; 
}; 

template< std::size_t N > 
struct make_indices { 
    typedef typename make_indices< N - 1 >::type::next type; 
}; 

template<> 
struct make_indices<0> { 
    typedef indices<> type; 
}; 

void f(int) {} 
void f(int, int) {} 

// helper function because we need a way 
// to deduce indices pack 

template<size_t... Is> 
void call_helper(const std::vector<int>& args, indices<Is...>) 
{ 
    f(args[Is]...); // expand the indices pack 
} 

template<std::size_t Arity> 
void call(const std::vector<int>& args) 
{ 
    if (args.size() < Arity) throw 42; 
    call_helper(args, typename make_indices<Arity>::type()); 
} 

int main() 
{ 
    std::vector<int> v(2); 
    call<2>(v); 
} 

Answer 2

Working example:

#include <cassert> 
#include <cstddef> 
#include <iostream> 
#include <vector> 

using namespace std; 

template <size_t... I> 
struct index_sequence {}; 

template <size_t N, size_t... I> 
struct make_index_sequence : public make_index_sequence<N - 1, N - 1, I...> {}; 

template <size_t... I> 
struct make_index_sequence<0, I...> : public index_sequence<I...> {}; 

int f(int a, int b) { 
    return a + b; 
} 
void f(int a, int b, int c) { 
    cout << "args = (" << a << ", " << b << ", " << c << ")\n"; 
} 

template <typename T, size_t... I> 
auto call_(const vector<T>& vec, index_sequence<I...>) 
    -> decltype(f(vec[I]...)) { 
    return f(vec[I]...); 
} 

template <size_t Arity, typename T> 
auto call(const vector<T>& vec) 
    -> decltype(call_(vec, make_index_sequence<Arity>())) { 
    assert(vec.size() >= Arity); 
    return call_(vec, make_index_sequence<Arity>()); 
} 

int main() { 
    vector<int> values = {0, 1, 2, 3, 4, 5}; 
    call<3>(values); 
    cout << "call<2>(values) = " << call<2>(values) << endl; 
}