Is there a way to use variable template as a parameter?

Question

I want to declare a function, which will take as a parameter a variable (let's say, int), which should be parametrized by a class. Speaking in terms of lambda calculus, I want my parameter to have a kind * -> int.

Example of a function I want to be able to write (Spec is the variable):

template <??? Specification, typename T>
auto make_array() {
    return std::array<T, Specification<T>>;
}

Since C++14 we have variable templates, so we can do something like this:

template <typename T>
constexpr int digits = std::numeric_limits<T>::digits;

The problem is, how do I pass that into a function? In the notes section of cppreference it is stated that

Variable templates cannot be used as template template arguments.

But does that mean that there is actually no way to pass parametrized variable as a function parameter? What you can do is, for example, create a class which has a static field denoting value, but an obvious drawback is that the users of my function must derive from that class.

I believe there might be some workaround using SFINAE, but I lack skills in that area.

Answer 1

Unless you insist on using a variable template, you can use a type trait:

template <typename T> struct Specification;

you can specialize it for example for int:

template <>
struct Specification<int> {
    static constexpr size_t value = 42;
};

and as you want to have different Specifications, pass it as template template parameter:

template <template<class> class S, typename T>
auto make_array() {
    return std::array<T, S<T>::value>{};
}

Complete example:

#include <array>
#include <cstddef>

template <template<class> class S, typename T>
auto make_array() {
    return std::array<T, S<T>::value>{};
}

template <typename T> struct Specification;

template <>
struct Specification<int> {
    static constexpr size_t value = 42;
};

int main(){
  auto x = make_array<Specification,int>();  
}

Note that I was rather verbose for the sake of clarity. You can save a bit of typing by using std::integral_constant, eg:

template <>
struct Specification<double> : std::integral_constant<size_t,3> {};

Answer 2

As an follow-up on idclev's answer, you can avoid the need to explicitly specialise for the different types for individual "specifications" just by inheriting from e.g. integral_constant. For example, your desired usage was something like

template <template <typename T> int Specification, typename T>
auto make_array() {
    return std::array<T, Specification<T>>;
}

template <typename T>
constexpr int digits = std::numeric_limits<T>::digits;

// ...

auto foo = make_array<digits, double>();

However, as you have noted, this is impossible: you cannot pass variable templates as template-template parameters. However, by turning digits into a structure directly you can do this:

template <template <typename T> class Specification, typename T>
auto make_array() {
    // we no longer have the guarantee of the type here, unfortunately
    // but you can use a static_assert to improve error messages
    // (also using `std::size_t` here for correctness)
    static_assert(
        std::is_convertible<decltype(Specification<T>::value), std::size_t>::value,
        "value must be convertible to size_t");
    
    return std::array<T, Specification<T>::value>;
}

// use a type rather than a variable template
// we just inherit from integral constant to save on some typing
// (though you could do this explicitly as well)
template <typename T>
struct digits : std::integral_constant<int, std::numeric_limits<T>::digits> {};

// ...

// same call!
auto foo = make_array<digits, double>();