具有可变参数的嵌套C ++模板

Question

I was wondering if it was possible to have nested C++ template and still be able to access the template values ? To explain, here is what I currently have:

template <int first, int... tail>
struct ConstIntVector:ConstIntVector<tail...>
{};

template <int first>
struct ConstIntVector<first>
{}; 

template<int f1, int... t1>
int prod(const ConstIntVector<f1, t1...>, const int* a) {
    return f1 * (*a) + prod(ConstIntVector<t1...>(), a+1);
}

This way, I can access the f1 value in my prod function. But I would like to do it like this:

template<ConstIntVector<int f1, int... t1>>
int prod(const int* a) {
    return f1 * (*a) + prod<ConstIntVector<t1...>>(a+1);
}

It is possible ?

Answer 1

Partial template specializations aren't allowed for member functions. But you can use a helper struct:

namespace detail
{
    template <typename T>
    struct prodHelper;

    template <int f1, int... t1>
    struct prodHelper<ConstIntVector<f1, t1...> >
    {
        static int eval(const int* a) { 
            return f1 * (*a) + prodHelper<ConstIntVector<t1...>>::eval(a+1);
        }
    };
}

template <typename T>
int prod(const int* a) {
    return detail::prodHelper<T>::eval(a);
}

Answer 2

Another option would be to utilize ConstIntVector structs to carry useful information:

template <int First, int... Tail>
struct ConstIntVector {
   constexpr static int value = First;
   using tail = ConstIntVector<Tail...>;
};

template <int First>
struct ConstIntVector<First> {
   constexpr static int value = First;
   using got_no_tail = void;
}; 

template <class CIV, typename CIV::tail* = nullptr>
int prod(const int* a) {
    return CIV::value * (*a) + prod<typename CIV::tail>(a+1);
}

template <class CIV, typename CIV::got_no_tail* = nullptr>
int prod(const int* a) {
    return CIV::value * (*a);
}

Answer 3

Just be aware, that recursion is neither necessary nor desirable to solve these kinds of TMP problems. First, it is better to simply define your vector like this:

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

That way you can have zero length vectors as well, which is convenient in handling edge cases (witness the fact that std::array can be length 0).

Next, lets write our product function. We'll modify it in two ways: first we'll infer the integer by trivially passing our ConstIntVector by value, and second we'll use pack expansions to avoid recursion.

template<int... Is>
int prod(const int* a, ConstIntVector<Is...>) {
    int index = 0;
    int sum = 0;
    int [] temp = {(sum += (a[index++] * Is))...};
    return sum;
}

Usage:

std::vector<int> v{1,2,3};
using v2 = ConstIntVector<4,5,6>;
std::cerr << prod(v.data(), v2{});

Live example: http://coliru.stacked-crooked.com/a/968e2f9594c6b292

Link to example of highly optimized assembly: https://godbolt.org/g/oR6rKe .

Answer 4

How about

template<int I>
int prod(const int* a) {
    return I * (*a);
}

template<int I, int I2, int... Is>
int prod(const int* a) {
    return I * (*a) + prod<I2, Is...>(a + 1);
}