有没有办法使用变量模板作为参数？

Question

我想声明一个函数，它将一个变量（比如说，int）作为参数，该变量应该由一个类参数化。说到 lambda 演算，我希望我的参数有一种 * -> int。

我希望能够编写的函数示例（Spec 是变量）：

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

由于 C++14 我们有可变模板，所以我们可以这样做：

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

问题是，我如何将它传递给函数？在cppreference 的注释部分指出

变量模板不能用作模板模板参数。

但这是否意味着实际上没有办法将参数化变量作为函数参数传递？例如，您可以创建一个具有表示值的静态字段的类，但一个明显的缺点是我的函数的用户必须从该类派生。

我相信使用 SFINAE 可能会有一些解决方法，但我缺乏这方面的技能。

Answer 1

除非你坚持使用变量模板，否则你可以使用类型特征：

template <typename T> struct Specification;

您可以将其专门用于int：

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

如果您想拥有不同的Specifications，请将其作为模板模板参数传递：

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>();  
}

请注意，为了清楚起见，我相当冗长。您可以使用std::integral_constant 节省一些打字时间，例如：

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

Answer 2

作为idclev's answer 的后续行动，您可以通过继承例如integral_constant。例如，您想要的用法类似于

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>();

但是，正如您所指出的，这是不可能的：您不能将变量模板作为模板模板参数传递。但是，通过将digits 直接转换为结构，您可以这样做：

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>();