结构元组/将一组可变的模板参数值包装在结构中

Question

我发现自己想要/需要使用可变参数复合类型作为模板参数。不幸的是，

std::tuple<>

不是一个结构类型，这使得明显的方法不可行：

#include <tuple>

template<typename... Ts>
struct composite {
  std::tuple<Ts...> operands;
};

template<auto v>
void foo() {}

int main() {
  constexpr composite tmp{std::make_tuple(1,2,3)};
  foo<tmp>();  // <----- Nope!
}

是否有一种合理的方法来以结构类型的方式构建这样的复合材料？

由于孤立的 MCVE 可以简单地解决为“只需使

foo()

成为可变参数模板”，这里有一个更具代表性的示例：

神螺栓

#include <concepts>
#include <tuple>

template <typename T, template <typename...> typename U>
concept TemplatedConfig = requires(T x) {
  { U(x) } -> std::same_as<T>;
  // A few more things identifying T as a valid config
};

template<auto Config>
struct proc;

// Basic
struct Basic {};

template<Basic v>
struct proc<v> {
    constexpr int foo() { return 0; }
};

// Annotated
template<typename T>
struct Annotated {
    T v;
    int annotation;
};

template<TemplatedConfig<Annotated> auto v>
struct proc<v> {
    constexpr int foo() { return 1; }
};

// ... more config / specialization pairs ...

// Composite
template<typename... Parts>
struct Composite {
    std::tuple<Parts...> parts;
};

template<TemplatedConfig<Composite> auto v>
struct proc<v> {
    constexpr int foo() { return 2; }
};


int main() {
    constexpr Basic a = Basic{};
    constexpr Annotated b{a, 12};
    constexpr Composite c{std::make_tuple(a, b)};

    static_assert(proc<a>{}.foo() == 0);
    static_assert(proc<b>{}.foo() == 1);
    static_assert(proc<c>{}.foo() == 2);   <----- :(
}

编辑：如果有人好奇基于接受的答案的（几乎）完全实现的元组类是什么样子：https://gcc.godbolt.org/z/ThaGjbo67

Answer 1

创建您自己的结构元组类？ 比如：

template <std::size_t I, typename T>
struct tuple_leaf
{
    T data;    
};

template <typename T> struct tag{ using type = T; };

template <typename Seq, typename...>
struct tuple_impl;

template <std::size_t... Is, typename... Ts>
struct tuple_impl<std::index_sequence<Is...>, Ts...> : tuple_leaf<Is, Ts>...
{
    constexpr tuple_impl(Ts... args) : tuple_leaf<Is, Ts>{args}... {}
};

template <typename T, std::size_t I> constexpr const T& get(const tuple_leaf<I, T>& t) { return t.data; }
template <typename T, std::size_t I> constexpr T& get(tuple_leaf<I, T>& t) { return t.data; }
template <std::size_t I, typename T> constexpr const T& get(const tuple_leaf<I, T>& t) { return t.data; }
template <std::size_t I, typename T> constexpr T& get(tuple_leaf<I, T>& t) { return t.data; }


template <std::size_t I, typename T>
tag<T> tuple_element_tag(const tuple_leaf<I, T>&);

template <std::size_t I, typename Tuple>
using tuple_element = decltype(tuple_element_tag<I>(std::declval<Tuple>()));

template <std::size_t I, typename Tuple>
using tuple_element_t = typename tuple_element<I, Tuple>::type;

template <typename ... Ts>
using tuple = tuple_impl<std::make_index_sequence<sizeof...(Ts)>, Ts...>;

演示