Get ordinal number of C++ variadic template parameter - c++

Question

I want to retrieve index of each parameter from variadic template parameters, currently I am using this approach:
From third party library:
struct statement {
template <typename T>
void bind(int, T t) { // ....
}
};
My code:
template <unsigned Index, typename T>
void bind(statement& stmt, T t) {
stmt.bind(Index, t);
}
template <unsigned Index, typename T, typename... Args>
void bind(statement& stmt, T t, Args... args) {
bind<Index>(stmt, t);
bind<Index + 1>(stmt,args...);
}
template <typename... Args>
void bind_all(statement& stmt, Args... args) {
constexpr int Index = 0;
bind<Index>(stmt, args...);
}
Usage:
statement stmt;
prepare(stmt, "insert into tab (a,b,c,d,e,f) values(?,?,?,?,?,?)");
bind_all(stmt, 1,1.24f, 3.14, "Hello", std::string{"World"}, true);
My question: Is there a better way to achieve this, to get ordinal numbers of variadic template parameters?
Edit:
I want to use this implementation to wrap sql prepared statement and to bind specific parameter to specific index.
Here is an example of code that I want to wrap, instead of listing each bind individually, I want to call bind_all
prepare(stmt, "insert into tab (a, b) values (?, ?);");
const int eight_int = 8;
stmt.bind(0, &eight_int);
const string eight_str = "eight";
stmt.bind(1, eight_str.c_str());
execute(stmt);

Answer 1

With simple expansion (could use a fold expression in C++17)
struct statement
{
template<class T>
void bind(int index, T&& arg)
{
// magic
}
};
template<class... Args>
void BindAll(statement& stmt, Args&&... args)
{
using swallow = int[];
int idx = 0;
(void)swallow{0, (void (stmt.bind(idx++, std::forward<Args>(args))), 0)...};
}
I took some liberties with the API, but I think it maps close enough to your code.
Usage:
statement stmt;
BindAll(stmt, 1, 1.2, 1.3f, true, "abc");
Demo

Answer 2

Why not use a std::tuple for this.
#include <utility>
#include <tuple>
template<typename T, std::size_t... Index>
void doBind(Statement& st, T const& tuple, std::index_sequence<Index...> const&)
{
// Using C++17 fold expression
((st.bind(Index, std::get<Index>(tuple))),...);
// Using C++11 dummy variable
int dummy[] = {0, (st.bind(Index, std::get<Index>(tuple)),0)...};
(void)dummy; // to prevent unused variable warning.
}
template<typename... Args>
void prepare(std::string const& sql, Args&&... args)
{
Statement statement;
prepare(statement, sql);
doBind(statement, std::make_tuple(args...), std::make_index_sequence<sizeof...(args)>());
execute(statement);
}

Answer 3

You could use std::index_sequence to create a second template parameter pack containing the matching indices:
template <typename... Args, size_t... Is>
void bind_all_helper(std::index_sequence<Is...>, Args... args) {
int dummy[]{(bind<Is>(args), 0)...};
(void)dummy; // just to avoid unused variable warnings
}
template <typename... Args>
void bind_all(Args... args) {
bind_all_helper(std::make_index_sequence<sizeof...(args)>{}, args...);
}
Live Demo
This uses a dummy array definition along with the comma operator to create a sequence of calls to bind. For example, given bind_all(1, 3.14), the array definition would expand to something like this:
int dummy[] {
(bind<0>(1), 0),
(bind<1>(3.14), 0)
};
Each element of the array ends up being 0, but its evaluation has the side-effect of calling bind<N>(arg).
With C++17 the dummy array definition could be replaced with a fold expression, but that obviously isn't an option if you're limited to C++14.