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

Question

我想写一个 class，它的大小为N （> 0），可变数为 arguments（>= N）。 它应该有一个采用 N arguments 的构造函数和一个具有相同类型的成员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

就我对这个问题的理解而言，它似乎只是在询问如何从 arguments 生成一个tuple 。使用Boost.Mp11 ，它是一个简短的单行代码（一如既往）：

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 2

这是一个使用 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元函数删除额外的模板 arguments。 但是，由于类型包不是第一个 class in typelist ，我们只能获取所需类型的类型列表。 要从给定的类型make_ctor typelist辅助类型。 通过继承它的构造函数，我们得到了想要的API。

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

Answer 3

使用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 4

您可以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 5

有所谓的Template Deduction Guides 。 它在下面的代码中用注释“// Template Deduction Guide”标记。

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

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

在线试用！

#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;
}

Output：

size 3 tuple 3 5.7 true