Is there something like is_empty_but_has_virtual_functions?

Question

I would like to craft an "interface"/mix-in class (template), and ensure nobody thinks that adding a member to this class template is a good idea, I'd like to static_assert on this condition. Unfortunately, std::is_empty does not allow virtual functions (as polymorphic classes need some space to store their virtual function table pointer or equivalent implementation details).

Is there a variant of std::is_empty that allows for virtual functions, but not data members (or is it easily written)?

I'd like this to work (plus all dark corner cases I can't think of right now):

#include <type_traits>

struct A {};
struct B : A {};
struct AA { virtual ~AA() = default; };
struct BB : AA {};

static_assert(std::is_empty_v<A>);
static_assert(std::is_empty_v<B>);

// These should also work with the replacement for is_empty:
static_assert(std::is_empty_v<AA>);
static_assert(std::is_empty_v<BB>);

int main()
{}

Live demo here.

I'm guessing it requires compiler magic or very platform-specific hacks/checks depending on how exactly virtual functions are implemented.

Answer 1

I would do this:

struct dummy_polymorphic
{
    virtual ~dummy_polymorphic() {}
};

template <typename T>
inline constexpr bool empty_maybe_polymorphic_v = std::is_empty_v<T> ||
    (std::is_polymorphic_v<T> && sizeof(T) <= sizeof(dummy_polymorphic));

It's the best approach I could think of, but it has some limitations:

• We assume that the overhead of a class being polymorphic is always the same (normally a pretty safe assumption, except if your class ends up with several vtable pointers due to multiple inheritance). I don't see any way to get rid of this limitation.

• It breaks if T has duplicate empty bases:

  struct A {};
  struct B : A{};
  struct C : A, B {virtual ~C() {}};
  
  std::cout << sizeof(C) << '\n'; // 16, rather than 8