Question

我有几个课程，比如A，B和C，以及相应的标记HAS_A=1，HAS_B=2和HAS_C=4。是否可以以这样的方式编写一个类，使其父（来自A，B和C）将由这些标志的组合决定？

示例：

ParentsFromFlags<HAS_A | HAS_C> x;
// x ends up having the features of A and C

我知道我可以使用<typename... Parents>变量多个父母，但我喜欢这样，因为我想确保A，B和{{1}是班级的父母，他们总是按照一定的顺序出现。

Answer 1

这样做的目的是以在层级中引入一些额外的课程为代价......

enum ParentFlags { HAS_A = 1, HAS_B = 2, HAS_C = 4 };

class A{};
class B{};
class C{};

template <int M>
class ParentClass {};

template <>
class ParentClass<0>{};

template <>
class ParentClass<HAS_A> : public A {};

template <>
class ParentClass<HAS_B> : public B{};

template <>
class ParentClass<HAS_C> : public C{};

template <int F, int M>
class ParentTraits : public ParentClass<F & M>, 
                     public ParentTraits<F & ~M, M << 1>
{};

template <int M>
class ParentTraits<0, M>
{};

template <int F>
class ParentFromFlags : public ParentTraits<F, 1>
{
};

int main()
{
    ParentFromFlags<HAS_A | HAS_B> ab;
    ParentFromFlags<HAS_A | HAS_C> ac;
    ParentFromFlags<HAS_A | HAS_B | HAS_C> abc;
    return 0;
}

Answer 2

这比你正在寻找的更通用，但现在你需要的是用filtered_list替换一个根据你的标志过滤类的元函数。

template<typename... T>
struct type_list;

template<typename T>
struct filtered_list;

template<typename T, typename... U>
struct filtered_list<type_list<T,U...>> {
    using type = type_list<U...>;
};

template<typename TypeList>
using filtered_list_t = typename filtered_list<TypeList>::type;

template<typename T>
struct collect_base_classes;

template<typename... T>
struct collect_base_classes<type_list<T...>> : public T... {};

struct A { void test_a() {} };
struct B { void test_b() {} };
struct C { void test_c() {} };

class Test : public collect_base_classes<filtered_list_t<type_list<A,B,C>>> {};

int main() {
    Test t;
    t.test_a(); //error, we dropped A from our base class list
    t.test_b();
    t.test_c();
}

Answer 3

有一种简单的方法和解决此问题的最佳方法。

最简单的解决方案是使用像conditional_t这样的编译时类型选择器，并结合空基类：

template <int M>
struct empty_base {};

template <int flags>
struct Foo 
    : std::conditional_t<flags & Has_A, A, empty_base<1>>
    , std::conditional_t<flags & Has_B, B, empty_base<2>>
    , std::conditional_t<flags & Has_C, C, empty_base<3>>
{
    int x;
};

这种方法的问题在于，由于使用了多重继承，它无法在C ++中触发empty base class optimization。结果，Foo值将是一个大于必要的单个词。

你可以通过以类似于boost.compressed_pair的方式链接基础来解决这个问题：

template <class T1, class T2>
struct compressed_pair_of_bases: T1, T2 {};

template <class T1, int N>
struct compressed_pair_of_bases<T1, empty_base<N>>: T1 {};

template <bool Predicate, class T, class Next>
using predicated_parent_chain_t = typename std::conditional_t<Predicate,
    compressed_pair_of_bases<T, Next>,
    Next>;

template <int flags>
struct Bar :
    predicated_parent_chain_t<!!(flags & Has_A), A,
        predicated_parent_chain_t<!!(flags & Has_B), B,
            predicated_parent_chain_t<!!(flags & Has_C), C,
                empty_base<1>>>>
{
    int x;
};

此解决方案能够在未选择基本类型时完全优化它们：

    std::cout << sizeof(Bar<0>); // prints 4 on a 32-bit target

Answer 4

实际上这就是我最终的结果。它与marom's solution基本相同，但更具可读性（至少对我而言）

enum ParentFlags { HAS_A = 1, HAS_B = 2, HAS_C = 4 };

class A { int a; };
class B { int b[2]; };
class C { int c[3]; };

template <int Flags>
class ParentA {};

template <>
class ParentA<HAS_A> : public A
{};

template <int Flags, int ThisFlag = Flags & HAS_B>
class ParentB : public ParentA<Flags & ~HAS_B>
{};

template <int Flags>
class ParentB<Flags, HAS_B> : public ParentA<Flags & ~HAS_B>, public B
{};

template <int Flags, int ThisFlag = Flags & HAS_C>
class ParentC : public ParentB<Flags & ~HAS_C>
{};

template <int Flags>
class ParentC<Flags, HAS_C> : public ParentB<Flags & ~HAS_C>, public C
{
};

template <int Flags>
class ParentFromFlags : public ParentC<Flags>
{};

基于标志的多重继承

4 个答案: