Is there a way to prevent a class from being derived from twice using a static assert and type trait?

Question

I realize this is a contrived example, but I want a compile check to prevent this...

class A {};
class B : public A {};
class C : public A {};

class D : public B, public C
{
    BOOST_STATIC_ASSERT((is_base_of_once<A,D>::value))
};

Answer 1

The following should work:

BOOST_STATIC_ASSERT(((A*)(D*)0 == 0)) 

If A exists twice, this should rise an ambiguity error, while otherwise the test will always succeed (because it compares two null pointers).

Answer 2

When I try to derive a class twice as you have here it does not even compile. (duplicate base type)

Answer 3

If you really want to, you an test both your base classes:

class A {};
class B : public A {};
class C : public A {};

class D : public B, public C
{
    static_assert(!(is_base_of<A,B>::value && is_base_of<A,C>::value),
                   "Invalid inheritance!");
};

Otherwise you can make the classes inherit virtually from A, so that there will still only be one instance of it in the derived class:

class A {};
class B : public virtual A {};
class C : public virtual A {};

class D : public B, public C
{
    // only one A here
};