Question

最初，我无法找到一种方法this，但是当我提出这个问题时，我想到了新的搜索词，终于找到了答案。我认为这篇文章都可以作为具有相同问题的任何人的重定向（因为花了一段时间才找到），我还想看看是否有任何方法可以改善语法糖，因为答案是9年老式和一些现代功能当时不可用。该答案中的代码：

#include <utility>

template <template<class> class... Mixins>
class Host : public Mixins<Host<Mixins...>>...
{
  public:
    Host(Mixins<Host>&&... args) : Mixins<Host>(std::forward<Mixins<Host>>(args))... {}
};

template <class Host> struct Mix1 {};
template <class Host> struct Mix2 {};

int main (void)
{
  typedef Host<Mix1, Mix2> TopHost;
  delete new TopHost(Mix1<TopHost>(), Mix2<TopHost>());
}

目标是消除每个mixin中多余的TopHost用法，因为这有点烦人，而且（更重要的是）如果不小心将错误类型与CRTP一起使用，可能会弄糟某些东西。我暗中怀疑这是可能的，因为使用可变参数来调用模板类型的构造函数肯定是可能的（例如new T（args ...））。

理想情况下，我们可以使用以下语法：

auto mix = TopHost(Mix1(args1...), Mix2(args2...), ...);

甚至（以某种方式）从using语句推导出mixins：

auto mix = TopHost({args1...}, {args2...}, ...);

编辑：因此，是的，的确，我在不知情的情况下为自己的问题提供了解决方案。第二种语法有效。如前所述，它不需要使用，因此仍然存在用户错误的可能性。 @Evg的解决方案确实做到了这一点，尽管它较为冗长，但从技术上讲可以回答问题，因此我暂时接受该回答。

现在我遇到的问题是，在我的应用程序中，mixins删除了复制构造函数，并且这两种方法都创建了副本（当然，这就是原始类的设计方式）。所以现在的问题变成了：是否有一种无需复制就可以实现语法的方法？我一直在尝试使类似的东西起作用，但似乎无法绕开如何扩展不同大小的可变参数模板的想法：

template < typename... > struct TypeList {};
template<typename TypeList> struct Variad;
template<typename... Types> struct Variad<TypeList<Types...>> {};

template<template<class> typename ...Args> struct Mixins;
template< class TemplList, class... Lists> struct Host;

template< template<class> class ...Components,  template<class...> class T, class... Variads>
struct Host<Mixins<Components...>, T<Variads>...> : 
  public Components<Host<Mixins<Components...>, T<Variads>...>>...
{
    Host(T<Variads>&&... args) : Components<Host<Mixins<Components...>, T<Variads>...>>(std::forward<T<Variads>...>(args))... {}
};

其用法如下：

int main() {
  using f1 = TypeList<int,int>;
  using f2 = TypeList<int>;
  using m1 = Mixins<Mix1, Mix2>;
  Host<m1, Variad<f1>, Variad<f2>> obj(1,2,3);
}

不一定干净，但就我而言更可取。我不确定该扩展的工作原理如何，但是我基于创建嵌套的variad的尝试来建立它，


#include <iostream>
#include <typeinfo>
#include <cxxabi.h>
#define get_type(x) (abi::__cxa_demangle(typeid(x).name(), NULL, NULL, NULL))

template < typename... > struct TypeList {};
template<typename TypeList> struct Variad;
template<typename... Types> struct Variad<TypeList<Types...>> {};

template<typename ...TypeListOne> struct NestedVariad;
template<template<class...> class T, typename...Types>
struct NestedVariad<T<Types>...> { };


int main() {
  using f1 = TypeList<int,int>;
  using f2 = TypeList<int>;

  NestedVariad<Variad<f1>, Variad<f2>> obj;
  cout << get_type(obj) << endl;
}

其输出：NestedVariad<Variad<TypeList<int, int> >, Variad<TypeList<int> > >

但是对于mixin类使用类似的方法将所有三个参数传递给每个构造函数，而不是将2个传递给第一个，将1个传递给第二个

Answer 1

正如 Oliv 在评论中所说，第二种语法有效：

template <class Host> struct Mix1 {
    Mix1(int, int) {}
};

template <class Host> struct Mix2 {
    Mix2(int) {}
};

using TopHost = Host<Mix1, Mix2>;
auto mix = TopHost({1, 1}, {2});

或者，您可以执行以下操作：

template<class TopHost, class Mixes, class Tuple, std::size_t... ii>
auto make_mix_impl(std::index_sequence<ii...>, Tuple&& tuple)
{
    return TopHost(std::make_from_tuple<std::tuple_element_t<ii, Mixes>>(
        std::get<ii>(std::forward<Tuple>(tuple)))...);
}

template<template<class> class... Mixes, class... Tuples>
auto make_mix(Tuples&&... tuples)
{
    static_assert(sizeof...(Mixes) == sizeof...(Tuples));
    using TopHost = Host<Mixes...>;
    return make_mix_impl<TopHost, std::tuple<Mixes<TopHost>...>>(
        std::make_index_sequence<sizeof...(Mixes)>{}, 
        std::make_tuple(std::forward<Tuples>(tuples)...));
}

auto mix = make_mix<Mix1, Mix2>(std::make_tuple(1, 1), std::make_tuple(2));

有没有更干净的方法将CRTP与可变参数继承混合在一起？

1 个答案: