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

下面是我想要的最接近的东西。
如果我将原始类型（例如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 { 
};

不过，在我看来，该语言没有这种功能。

（我是可变参数模板的新手。）

Answer 1

简单答案

您必须在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>>;

定义一个类`MultiInherit <mytuple <x1，x2，... >>`继承自`X1，X2，...`

尝试1

尝试2

1 个答案:

简单答案

更一般的情况