受@dfri的启发，我将她/他的解决方案转换为可以省略函数的版本，但只使用一个结构体，该结构体使用std::integer_sequence的部分模板特化，其他人可能也会感兴趣：

template <auto arr, template <typename X, X...> typename Consumer,
          typename IS = decltype(std::make_index_sequence<arr.size()>())> struct Generator;

template <auto arr, template <typename X, X...> typename Consumer, std::size_t... I>
struct Generator<arr, Consumer, std::index_sequence<I...>> {
  using type = Consumer<typename decltype(arr)::value_type, arr[I]...>;
};

用法完整示例：

#include <array>

/// Structure which wants to consume the array via a parameter pack.
template <typename StructuralType, StructuralType... s> struct ConsumerStruct {
  constexpr auto operator()() const { return std::array{s...}; }
};

/// Solution
template <auto arr, template <typename X, X...> typename Consumer,
          typename IS = decltype(std::make_index_sequence<arr.size()>())> struct Generator;

template <auto arr, template <typename X, X...> typename Consumer, std::size_t... I>
struct Generator<arr, Consumer, std::index_sequence<I...>> {
  using type = Consumer<typename decltype(arr)::value_type, arr[I]...>;
};

/// Helper typename
template <auto arr, template <typename T, T...> typename Consumer>
using Generator_t = typename Generator<arr, Consumer>::type;

// Usage
int main() {
  constexpr auto tup = std::array<int, 3>{{1, 5, 42}};
  constexpr Generator_t<tup, ConsumerStruct> tt;
  static_assert(tt() == tup);
  return 0;
}

一种C++20方法

请参见OP's own answer，或者revision 2 of this answer（可能有指导意义，但更冗长（也不太有用））。

一种C++17方法

• （这个答案最初包含了一个使用C20的次要特性的方法（没有任何捕获的lambda可能是默认构造的），但受最初答案的启发，OP提供了一种更简洁的C20方法，它利用了constexprstd::array福尔斯可以在C20中作为非类型模板参数传递的文本类这一事实（给定对::value_type的约束），结合使用索引序列的部分专用化，用于将数组解包到参数包中。利用将std::array Package 成constexpr λ的技术（〉=C17），它充当constexpr（特定的）std::array创建者，而不是实际的constexprstd::array。有关此方法的详细信息，请参见see revision 2 of this answer）*

遵循OP简洁的方法，下面是它在C++17中的修改，使用非类型左值引用模板参数在编译时提供对数组的引用。

#include <array>
#include <cstdlib>
#include <tuple>
#include <type_traits>
#include <utility>

// Parameter pack structure (concrete target for generator below).
template <typename StructuralType, StructuralType... s>
struct ConsumerStruct
{
    // Use tuple equality testing for testing correctness.
    constexpr auto operator()() const { return std::tuple{s...}; }
};

// Generator: FROM std::array TO Consumer.
template <const auto& arr,
          template <typename T, T...> typename Consumer,
          typename Indices = std::make_index_sequence<arr.size()> >
struct Generator;

template <const auto& arr,
          template <typename T, T...> typename Consumer,
          std::size_t... I>
struct Generator<arr, Consumer, std::index_sequence<I...> >
{
    using type =
        Consumer<typename std::remove_cv<typename std::remove_reference<
                     decltype(arr)>::type>::type::value_type,
                 arr[I]...>;
};

// Helper.
template <const auto& arr, template <typename T, T...> typename Consumer>
using Generator_t = typename Generator<arr, Consumer>::type;

// Example usage.
int main()
{
    // As we want to use the address of the constexpr std::array at compile
    // time, it needs to have static storage duration.
    static constexpr std::array<int, 3> arr{{1, 5, 42}};
    constexpr Generator_t<arr, ConsumerStruct> cs;
    static_assert(cs() == std::tuple{1, 5, 42});
    return 0;
}

注意，这种方法对std::array示例有一个限制，即它需要有静态的存储持续时间。如果想避免这种情况，可以使用constexpr lambda来生成数组。

您还可以执行以下操作：

template<typename T, T... Values>
struct ResultStruct
{};

template<template<typename T, T... Values> typename ResultType, typename ElementType, size_t N, std::array<ElementType, N> Array, size_t... Is>
auto as_pack_helper(std::integer_sequence<size_t, Is...>) -> ResultType<ElementType, Array[Is]...>;

template<template<typename T, T... Values> typename ResultType, std::array Array>
using as_pack_t = decltype(as_pack_helper<ResultType, typename decltype(Array)::value_type, Array.size(), Array>(std::make_index_sequence<Array.size()>{}));

static_assert(std::is_same_v<as_pack_t<ResultStruct, std::array<int, 3>{1, 2, 3}>, ResultStruct<int, 1, 2, 3>>);

它的工作原理与解决方案非常相似，但是使用decltype和函数定义来生成结果类型!