定义一个类`MultiInherit >`继承自`X1，X2，......`

Question

如何定义一个类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

以下是最接近我想要的。 如果我将原始类型（例如qazxsw poi）作为模板参数而不是qazxsw poi，那将很容易： - （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。

尝试2

我想在MyTuple<B,C>中添加一个新的variadic typedef B,C： -

MyXs

然而，在我看来，语言没有这样的特征。

（我是variadic模板的新手。）

Answer 1

Simple answer

你必须MyTuple的

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

。让我们看一下create a template specialization的基本情况：

MultiInherit

在这里，我们采用一堆类型并从中继承。但我们可以使用模板专门化来解包元组：

MultiInherit

这可以让你做你想要的。鉴于

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

，你有一个继承自所有成员的

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

类。

More general case

定义类型列表。如果你想更普遍地做一些事情，那么根据表示类型列表的模板来做它们会很有用。我们可以定义一个模板来表示一个类型列表：

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

concat的例子。或者，如果你想连接多个MultiInherits并将其转换为

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

：

TypeList