3

我有一个应用程序，我正在从参数包中构造元组：

template<class... T>
struct foo {
 typedef std::tuple<T...> A;
}

我有另一个元组类型 B 定义为：

typedef std::tuple<char, int> B;

有没有办法获得一个新的 tuple C，例如在集合和编译时C对集合中的类型进行集合减法？AB

A = {int, double, float, bool}
B = {char, int}
C = A - B = {double, float, bool} // answer

完整问题的更多上下文：

template<class... T>
struct foo {
 using first_type = typename std::tuple_element<0, // n'th type 
                     std::tuple<T...>>::type;
}

我可以通过上述方法找到第 0 种类型，但我对第 B 组中不包含的第一种类型感兴趣。所以，有点像编译时搜索来查找第一个有效类型。

4

2 回答 2

3

这是一个编译时集减法，将其用作set_diff<tuple1, tuple2>::type：

template <class...> class set_diff;

template <class... A, class... B>
struct set_diff<std::tuple<A...>, std::tuple<B...>>
{
    template <class J, class... Js>
    constexpr static bool exists_in = std::disjunction_v<std::is_same<J, Js>...>;

    using type = decltype(tuple_cat(std::declval<
      std::conditional_t<exists_in<A, B...>, std::tuple<>, std::tuple<A>>>()...));
};

Demo

注意：

  • 操作数的顺序很重要（根据问题描述）
  • 编译复杂性可能有各种“优化”（例如，对类型进行排序和在 diff 之前删除重复项等）。

我的解决方案分两步进行：

  1. 将“不需要的”类型标记为tuple<>
  2. 生成所需的typeusing tuple_cat，它驱逐空元组

可以在这里找到一个更不言自明（唉更冗长）的演示 Demo

于 2021-05-01T23:38:24.730 回答
1

免责声明。请不要将这样的代码放入实际的代码库中。如果你这样做了，这个实现绝不是“最佳的”，应该在使用前清理（如果你这样做，可能会添加一个答案）。

我发现这是一个有趣的挑战，并找到了以下解决方案：

// Try this live at https://compiler-explorer.com/z/cqebd81ss

#include <type_traits>

template <typename... Pack>
struct ClassList;

template<typename...>
struct Join {
};
template<typename... Pack1, typename... Pack2>
struct Join<ClassList<Pack1...>, ClassList<Pack2...>> {
    using Type = ClassList<Pack1..., Pack2...>;
};

template<typename...>
struct RemoveSingleTypeFromList {
};
template<typename Target, typename... Pack>
struct RemoveSingleTypeFromList<Target, ClassList<Pack...>> {
    using Type = ClassList<Pack...>;
};
template<typename Target, typename Parameter, typename... Pack>
struct RemoveSingleTypeFromList<Target, ClassList<Parameter, Pack...>> {
    using Type = typename Join<
        std::conditional_t<
            std::is_same_v<Target, Parameter>,
            ClassList<>,
            ClassList<Parameter>
        >,
        typename RemoveSingleTypeFromList<Target, ClassList<Pack...>>::Type
    >::Type;
};

template<typename... Pack>
struct RemoveTypesFromList {
};
template<typename... Types>
struct RemoveTypesFromList<ClassList<>, ClassList<Types...>> {
    using Type = ClassList<Types...>;
};
template<typename Target, typename... RemainingTargets, typename... Types>
struct RemoveTypesFromList<ClassList<Target, RemainingTargets...>, ClassList<Types...>> {
    using Type = typename RemoveSingleTypeFromList<
        Target,
        typename RemoveTypesFromList<
            ClassList<RemainingTargets...>,
            ClassList<Types...>
        >::Type
    >::Type;
};

// A few test cases to verify that it works

static_assert(std::is_same_v<
    typename RemoveTypesFromList<
        ClassList<int, float>,
        ClassList<float, double, int, long>
    >::Type,
    ClassList<double, long>>);

static_assert(std::is_same_v<
    typename RemoveTypesFromList<
        ClassList<float>,
        ClassList<float, double, float>
    >::Type,
    ClassList<double>>);

static_assert(std::is_same_v<
    typename RemoveTypesFromList<
        ClassList<int, int>,
        ClassList<float, double, float>
    >::Type,
    ClassList<float, double, float>>);

如果您有兴趣确切了解其工作原理，请记住这是一个解决方案，而不是您可以从上到下编写的东西。在阅读这样的模板代码时，我发现逐步构建类似的实现最有用。

于 2021-05-01T17:01:03.023 回答