Below is a wild, not thoroughly tested attempt at doing something helpful with C++11 only (actually, it does not really require any C++11 feature, but it's easier to write this way).
However, this trait only checks the transitive closure of the "is primary base class of" property: I could not figure out a non-intrusive way of verifying whether a class is a direct base class of another class.
#include <type_traits>
template<typename B, typename D, D* p = nullptr, typename = void>
struct is_primary_base_of : std::false_type { };
template<typename B, typename D, D* p>
struct is_primary_base_of<B, D, p,
typename std::enable_if<
((int)(p + 1024) - (int)static_cast<B*>(p + 1024)) == 0
>::type
>
:
std::true_type { };
Here is an example:
struct A { virtual ~A() { } };
struct B : A { };
struct C { virtual ~C() { } };
struct D : B, C { };
struct E : virtual A, C { };
int main()
{
// Does not fire (A is PBC of B, which is PBC of D)
static_assert(is_primary_base_of<A, D>::value, "Error!");
// Does not fire (B is PBC of C)
static_assert(is_primary_base_of<B, D>::value, "Error!");
// Fires (C is not PBC of D)
static_assert(is_primary_base_of<C, D>::value, "Error!");
// Fires (A is inherited virtually by E, so it is not PBC of E)
static_assert(is_primary_base_of<A, E>::value, "Error!");
// Does not fire (C is the first non-virtual base class of E)
static_assert(is_primary_base_of<C, E>::value, "Error!");
}