将可变参数包缩短为 N 种类型

Question

我想编写一个 class，它的大小为 N（> 0），参数数量可变（>= N）。它应该有一个带有 N 个参数的构造函数和一个具有相同类型的成员 std::tuple：

template <size_t N, typename... Args>
struct Example {
  // A constructor taking N parameters of type Args[N], initializing the member tuple 
  // (e.g. param 1 has type Args[0], param 2 has type Args[1], ..., 
  // param N has type Args[N-1])
  // A tuple with N elements, each corresponding to Args[N]
  // (e.g. std::tuple<Args[0], ..., Args[N-1]>)

  //For instance Example<3, int, float, int, bool> should result in
  constexpr Example(int a, float b, int c): t(a, b, c) {}
  std::tuple<int, float, int> t;
}

总的来说：这可能吗？如果没有，是否有可行的替代方案？为什么/这不起作用？我正在使用 C++20。

Answer 1

这是一个使用 C++20 的实现：

#include <cstddef>
#include <utility>
#include <tuple>

template <class... Ts> struct typelist;

template <size_t N, class, class> struct take;

// Takes N elements of the given type pack
template <size_t N, class... Ts>
using take_t = typename take<N, typelist<>, typelist<Ts...>>::type;

template <class Take, class Drop>
struct take<0, Take, Drop>  {
    using type = Take;
};

template <size_t N, class T, class... Ts, class... Us>
requires(N > 0)
struct take<N, typelist<Us...>, typelist<T, Ts...>> {
    using type = typename take<N - 1, typelist<Us..., T>, typelist<Ts...>>::type;
};

template <class Ts> 
struct make_ctor;

template <class... Ts>
struct make_ctor<typelist<Ts...>> {
    constexpr make_ctor(Ts... ts) : tuple(ts...) {}

    std::tuple<Ts...> tuple;
};

template <size_t N, class... Args>
struct Example : 
    make_ctor<take_t<N, Args...>> {
    using make_ctor<take_t<N, Args...>>::make_ctor;
};

int main() {
    Example<3, int, float, int, bool> e(3, 3.14, 4);
}

我们在这里做的是，首先我们使用 take meta-function 删除额外的模板参数。但是，由于类型包在 C++ 中不是第一个 class，我们只能获取所需类型的 typelist。要从给定的 typelist 创建元组 + 构造函数，我们有一个名为 make_ctor 的辅助类型。通过继承它的构造函数，我们得到了想要的API.

对于生产，请参阅 Barry 的回答并为元编程部分使用现有的库。

Answer 2

您可以 make_index_sequence<N> 帮助从 Args... 中提取第一个 N。

示例：

#include <iostream>
#include <tuple>
#include <type_traits>
#include <utility>

// Create a tuple from the sizeof...(I) first elements in the supplied tuple:
template <class... Ts, size_t... I>
constexpr auto extract_from_tuple(std::tuple<Ts...>&& tmp, std::index_sequence<I...>) {
    static_assert(sizeof...(Ts) >= sizeof...(I));
    // make a new tuple:
    return std::make_tuple(std::move(std::get<I>(tmp))...);
}

template <size_t N, class... Args>
struct Example {
    template<class... Ts, std::enable_if_t<sizeof...(Ts)==N, int> = 0>
    constexpr Example(Ts&&... args)
        : t{extract_from_tuple(std::make_tuple(std::forward<Ts>(args)...), 
            std::make_index_sequence<N>{})} {}

    // using the same extract_from_tuple function to deduce the type of `t`
    decltype(extract_from_tuple(std::make_tuple(std::declval<Args>()...),
                                std::make_index_sequence<N>{})) t;
};

int main() {
    Example<3, int, float, double, bool> foo(1, 2.f, 3.);

    static_assert(std::is_same_v<decltype(foo.t), std::tuple<int, float, double>>);
}

Answer 3

就我对这个问题的理解而言，它似乎只是在询问如何根据参数生成 tuple。其中，使用 Boost.Mp11，是一个简短的 one-liner（一如既往）：

template <size_t N, typename... Args>
using Example = mp_take_c<N, std::tuple<Args...>>;

而不是 Example<3, int, float, int, bool> 是具有成员 tuple<int, float, int> 和一个构造函数的某种类型，它实际上是 tuple<int, float int>.

如果您出于某种原因特别需要一个成员元组和指定的构造函数，我们可以轻松完成：

template <typename... Ts>
struct ExampleImpl {
    std::tuple<Ts...> t;
    constexpr ExampleImpl(Ts... ts) : t(ts...) { }
};

template <size_t N, typename... Args>
using Example = mp_take_c<N, ExampleImpl<Args...>>;

Answer 4

使用 std::tuple_element 和辅助基础 class，在我看来，您可以编写如下内容（C++14 就足够了）

#include <tuple>
#include <string>

template <typename ...>
struct ExHelper;

template <std::size_t ... Is, typename Tpl>
struct ExHelper<std::index_sequence<Is...>, Tpl>
{
  using t_type = std::tuple<typename std::tuple_element<Is, Tpl>::type...>;

  t_type  t;

  constexpr ExHelper(typename std::tuple_element<Is, Tpl>::type ... args)
    : t{std::move(args)...}
  { }
};

template <std::size_t N, typename... Args>
struct Example : public ExHelper<std::make_index_sequence<N>,
                                 std::tuple<Args...>> {
  static_assert( N <= sizeof...(Args), "!" );

  using ExHelper<std::make_index_sequence<N>,
                 std::tuple<Args...>>::ExHelper;
};

int main ()
{
  Example<3, int, float, int, std::string>  e0{1, 2.0f, 3};

  static_assert( std::is_same<decltype(e0)::t_type,
                              std::tuple<int, float, int>>::value, "!" );
}

Answer 5

有so-calledTemplate Deduction Guides个。它在下面的代码中用注释“//模板推导指南”标记。

本指南展示了如何从构造函数的参数中推导出结构的模板类型。

现在您可以使用任何类型调用构造函数（就像我在 main() 中所做的那样）。

Try it online!

#include <tuple>

template <std::size_t N, typename ... Args>
struct Example {
    constexpr Example(Args && ... args)
        : t(std::forward<Args>(args)...) {}
    std::tuple<Args...> t;
};

// Template Deduction Guide
template <typename ... Args>
Example(Args && ...) -> Example<sizeof...(Args), Args...>;

#include <iostream>
#include <iomanip>

int main() {
    Example example(int{3}, float{5.7}, bool{true});
    std::cout
        << std::boolalpha << "size "
        << std::tuple_size_v<decltype(example.t)> << " tuple "
        << std::get<0>(example.t) << " " << std::get<1>(example.t)
        << " " << std::get<2>(example.t) << std::endl;
}

输出：

size 3 tuple 3 5.7 true

将可变参数包缩短为 N 种类型

Shorten variadic parameter pack to N types

c++

variadic-templates

c++20