c++ - 定义一个类 `MultiInherit<MyTuple<X1,X2,…>>`继承自 `X1,X2,…`

如何定义一个从MultiInherit<MyTuple<X1,X2,...>>继承的X1,X2,...类？
我想传递MyTuple<X1,X2,...>组成一个新的对象类型。

template <class... Xs> class MyTuple{};
template <class MyTupleXs> class MultiInherit : public All_Xs_in_MyTupleXs { //??

};

这是它的用法和MCVE(不可编译):

class B{public: int b;};
class C{public: int c;};
class BC : public MultiInherit<MyTuple<B,C>> {
    public: void testCompile(){
        this->b=this->c;
    }
};
int main(){
}

尝试1

以下是最接近我想要的东西。
如果我将原始类型(例如B,C)作为模板参数而不是MyTuple<B,C>，它将很容易:-
(MCVE，可编译)

template <class... Xs> class MultiInherit : public Xs... {
};
class B{public: int b;};
class C{public: int c;};
class BC : public MultiInherit<B,C> {
    public: void testCompile(){
        this->b=this->c;
    }
};

引用:Variadic templates and multiple inheritance in c++11
这不能解决。我想传递一个封装的MyTuple<B,C>类型，而不是B,C类型。

尝试2

我考虑过在MyXs中添加新的可变参数typedef MyTuple:-

template <class... Xs> class MyTuple{
   public: using MyXs=Xs...;
};
template <class MyTupleXs> class MultiInherit : public MyTupleXs::MyXs {
};

但是，在我看来，该语言没有这种功能。

(我是可变参数模板的新手。)

最佳答案

简单的答案

您必须MultiInherit的create a template specialization。让我们看一下MultiInherit的基本情况:

template<class... Xs>
class MultiInherit : public Xs... {
    // Stuff
};

在这里，我们采用一堆类型并从它们继承。但是我们可以使用模板特化来解压缩元组:

// Specialization on MyTuple
template<class... Xs>
class MultiInherit<MyTuple<Xs...>> : public Xs... {
     // Stuff
};

这使您可以做自己想做的事。给定MyTuple，您就有一个MultiInherit类，该类继承自所有成员。

更一般的情况

定义类型列表。 如果您想做更一般的事情，那么根据代表类型列表的模板来做就很有用。我们可以定义一个模板来表示类型列表:

template<class...>
struct TypeList {};

串联类型列表。 我们可以定义更多模板来连接类型列表。 ConcatLists是一个接受两个类型列表的函数，并返回将它们串联在一起的TypeList:

template<class... Xs, class... Ys>
TypeList<Xs..., Ys...> ConcatLists(TypeList<Xs...>, TypeList<Ys...>) {
    return {};
}

我们可以使用它来定义一个自动执行的concat_t:

template<class TypeListA, class TypeListB>
using concat_t = decltype(ConcatLists(TypeListA{}, TypeListB{}));

用MultiInherit替换TypeList。 我们还可以使用模板特化功能将一种类型替换为另一种类型。

// Base case
template<template<class...> class Replacement, class List>
struct SubstituteList;

template<
    template<class...> class Replacement,
    template<class...> class Original,
    class... Xs>
struct SubstituteList<Replacement, Original<Xs...>> {
    using type = Replacement<Xs...>;
};

template<template<class...> class Replacement, class List>
using substitute_list_t = typename SubstituteList<Replacement, List>::type;

这意味着您可以采用TypeList并将其替换为MultiInherit:

template<class ListOfTypes>
using MultiInheritFromTypeList = substitute_list_t<MultiInherit, ListOfTypes>;

用法示例。 如果您想将TypeList转换为MultiInherit:

using T1 = TypeList<int, char, bool>;
// T2 is MultiInherit<int, char, bool>;
using T2 = MultiInheritFromTypeList<T1>;

带有concat的示例。 或者，如果要连接多个TypeList并将其转换为MultiInherit:

using T1 = TypeList<int, char, bool>;
using T2 = TypeList<double, float>;
// T3 is MuliInherit<int, char, bool, double, float>
using T3 = MultiInheritFromTypeList<concat_t<T1, T2>>;