C++ Variadic template - Unable to figure out the compilation error

Ok, I'll try to give you a scheme, how you should declare variadic templates.

Except the case of a forwarder, when you can simply define just one variadic-template version, which will redirect to another variadic-template function, you will always have two versions, let's call them closed and open.

The open version is a version with variadic template. This shall do some "continuation" on next arguments. The closed version has a fixed number of arguments. The most important thing is that these versions be distinguishable by the compiler basing on the rules of function overloading resolution (similar it's with the class templates and partial specialization, you'll figure it out easily once you get the scheme for the functions). Another important thing of course is that the open version must contain at least one fixed argument because this is the only way how to split the argument pack into an argument and the "rest".

In general, you have two possibilities:

1. Closed version operates with argument, Open version does iteration. Example: template <class T> size_t Size(T arg) { return 1; } template <class T1, class T2, class... Args> size_t Size(T1 t1, T2 t2, Args... args) { return Size(t1) + Size(t2, args...); } In this case the version are distinguished by the compiler because the closed version uses one argument and the open version uses two at least arguments. The open version cannot use just T1 and Args because this way it could be called with exactly one argument (Args... is potentially unlimited number of arguments including empty list).

2. Closed version does nothing (just terminates the iteration), Open version does the job and the iteration. Example: size_t Size() { return 0; } template <class T1, class... Args> size_t Size(T1 t1, Args... args) { return 1 + Size(args...); } In this case the call: Size(args...) will potentially resolve into either this function itself, with the difference that it will skip the first argument, or into Size(), if the args... list at some iteration happens to be already empty.

I have a feeling that in your code you haven't exactly decided, which scheme you want to follow, and which of the versions is going to make an operation on the data, and which should continue iteration. The exact problem in your code is that this call:

fetchColumn<index + 1, T, V...>(row, nullptr);

May need to sometimes resolve into such a declaration (because V... resolves to nothing and the effective list of template arguments is index+1, T):

template<int index, typename T> void SelectOperation::fetchColumn(T& row, void*) const

and you haven't declared it.