从模板包生成大小为 N 的所有子包

大小为 N 的所有Types...子集组成的包包。例如

NSubsets<2, Pack<int, char, double>>::type

是要

Pack<Pack<int, char>, Pack<int, double>, Pack<char, double>>

一种方法是简单地从从包中获取所有子包中获取PowerSet解决方案的输出，然后取出每个不是 N 码的包装。 但是这对于大N来说效率太低了(无论如何都是糟糕的(。 这是我的想法(灵感来自优雅的PowerSet解决方案(： 假设我们有 Pack<A,B,C,D> 个，并且 N = 2。 从 Pack<> 开始，我们遍历 Pack<A,B,C,D> 中的类型并附加每个类型，如下所示：在附加任何内容之前，我们有：

Pack<>

将 A 附加到前一个(并保留前一个(，我们得到：

Pack<>, Pack<A>

将 B 附加到前一个(并保留前一个(，我们得到：

Pack<>, Pack<A>, Pack<B>, Pack<A,B>,

但是Pack<A,B>有 2 号，所以把它藏起来，从这个列表中拿出来，给我们留下：

Pack<>, Pack<A>, Pack<B>

将 C 附加到前一个(并保留前一个(，我们得到：

Pack<>, Pack<A>, Pack<B>, Pack<C>, Pack<A,C>, Pack<B,C>.

像上面一样，藏匿Pack<A,C>, Pack<B,C>：

Pack<>, Pack<A>, Pack<B>, Pack<C>

将 D 附加到前一个(并保留前一个(，我们得到：

Pack<D>, Pack<A,D>, Pack<B,D>, Pack<C,D>.

再次拿 2 码的那些，我们现在终于有了

Pack<Pack<A,B>, Pack<A,C>, Pack<B,C>, Pack<A,D>, Pack<B,D>, Pack<C,D>>

作为我们想要的输出。

请注意，此算法中的一个缺陷是无缘无故地将Pack<>保持在倒数第二步。 如果 N 大于 2，这个无关的部分真的会浪费时间。 以下是我使用上述方法的代码，但输出给出 false，我无法追踪原因(还(。 但即使如果它确实正常工作，我仍然不太喜欢它，主要是因为我刚才提到的上面提到的缺陷，我不知道如何以消除该缺陷。

#include <iostream>
#include <type_traits>
template <int, typename> struct IsSize;
template <int N, template <typename...> class P, typename... Types>
struct IsSize<N, P<Types...>> : std::integral_constant<bool, sizeof...(Types) == N> {};
template <int, typename, typename, typename> struct PartitionPacksBySizeHelper;
template <int N, template <typename...> class P, typename... KeptPacks, typename... SizeNPacks>
struct PartitionPacksBySizeHelper<N, P<>, P<KeptPacks...>, P<SizeNPacks...>> {
    using not_sizeN_types = P<KeptPacks...>;
    using sizeN_types = P<SizeNPacks...>;
};
template <int N, template <typename...> class P, typename First, typename... Rest, typename... KeptPacks, typename... SizeNPacks>
struct PartitionPacksBySizeHelper<N, P<First, Rest...>, P<KeptPacks...>, P<SizeNPacks...>> : std::conditional<IsSize<N, First>::value,
        PartitionPacksBySizeHelper<N, P<Rest...>, P<KeptPacks...>, P<SizeNPacks..., First>>,
        PartitionPacksBySizeHelper<N, P<Rest...>, P<KeptPacks..., First>, P<SizeNPacks...>>
    >::type {};
template <int, typename> struct PartitionPacksBySize;
template <int N, template <typename...> class P, typename... Packs>
struct PartitionPacksBySize<N, P<Packs...>> : PartitionPacksBySizeHelper<N, P<Packs...>, P<>, P<>> {};
template <typename, typename> struct Append;
template <typename T, template <typename...> class P, typename...Types>
struct Append<T, P<Types...>> {
    using type = P<Types..., T>;
};
template <int, typename, typename, typename> struct NSubsetsHelper;
template <int N, template <typename...> class P, typename... CurrentPacks, typename... AccumulatedPacks>
struct NSubsetsHelper<N, P<>, P<CurrentPacks...>, P<AccumulatedPacks...>> {
    using type = P<AccumulatedPacks...>;
};
template <int N, template <typename...> class P, typename First, typename... Rest, typename... KeptPacks, typename... SizeNPacks>
struct NSubsetsHelper<N, P<First, Rest...>, P<KeptPacks...>, P<SizeNPacks...>>
    : NSubsetsHelper<N, P<Rest...>,
        typename PartitionPacksBySize<N, P<KeptPacks..., typename Append<First, KeptPacks>::type...>>::not_sizeN_types,
        typename PartitionPacksBySize<N, P<KeptPacks..., typename Append<First, KeptPacks>::type...>>::sizeN_types> {};
template <int, typename> struct NSubsets;
template <int N, template <typename...> class P, typename...Types>
struct NSubsets<N, P<Types...>> : NSubsetsHelper<N, P<Types...>, P<P<>>, P<>> {};
// -----------------------------------------------------------------------------------------------------------------------------------------------
// Testing
template <typename...> struct Pack {};
int main() {
    std::cout << std::boolalpha << std::is_same< NSubsets<2, Pack<int, char, double>>::type,
        Pack<Pack<int, char>, Pack<int, double>, Pack<char, double>>
    >::value << std::endl;  // false (darn!)
}

我在纸上追踪到上面的包应该是输出，当我改变包的顺序时，它仍然给出 false。 但是，正如我上面提到的，该方法无论如何都是劣质的。 关于更好的方法有什么建议吗？

更新：我发现了我的错误，并更换了

typename PartitionPacksBySize<N, P<KeptPacks..., typename Append<First, KeptPacks>::type...>>::sizeN_types>

跟

typename Merge<P<SizeNPacks...>, typename PartitionPacksBySize<N, P<KeptPacks..., typename Append<First, KeptPacks>::type...>>::sizeN_types>::type

但是，你仍然看到我的算法在 N 很大时的最后 N 次迭代中是如何浪费时间的？