Проверить, переопределяет ли подкласс виртуальную функцию в базовом классе

В C++11 и более поздних версиях, сравнивая типы функций по decltype и std::is_same, мы можем получить желаемые результаты. (Если C++11 недоступен для вас, вы все равно можете использовать для этой цели typeid и operator==(const type_info& rhs).)

Поскольку Base::vfoo переопределяется Child, тип decltype(&Child::vfoo) равен void (Child::*)() и отличается от decltype(&Base::vfoo), который является void (Base::*)(). Таким образом

std::is_same<decltype(&Base::vfoo) , decltype(&Child::vfoo)>::value

это false.

(На самом деле, в пункте 4 черновика стандарта C++ n3337, в котором перечисляется набор неявных преобразований, 4.11 Преобразование указателя на элемент [conv.mem] / 2,

2. A prvalue of type “pointer to member of B of type cv T”, where B is a class type, can be converted to a prvalue of type “pointer to member of D of type cv T”, where D is a derived class (Clause 10) of B. If B is an inaccessible (Clause 11), ambiguous (10.2), or virtual (10.1) base class of D, or a base class of a virtual base class of D, a program that necessitates this conversion is ill-formed. The result of the conversion refers to the same member as the pointer to member before the conversion took place, but it refers to the base class member as if it were a member of the derived class. The result refers to the member in D’s instance of B. Since the result has type “pointer to member of D of type cv T”, it can be dereferenced with a D object. The result is the same as if the pointer to member of B were dereferenced with the B subobject of D. The null member pointer value is converted to the null member pointer value of the destination type.

, утверждает, что неявное преобразование из decltype(&Base::vfoo) в decltype(&Child::vfoo) может быть допустимым, но не упоминает об обратном направлении. Кроме того, 5.2.9 Статическое приведение [expr.static.cast] / 12,

12. A prvalue of type “pointer to member of D of type cv1 T” can be converted to a prvalue of type “pointer to member of B” of type cv2 T, where B is a base class (Clause 10) of D, if a valid standard conversion from “pointer to member of B of type T” to “pointer to member of D of type T” exists (4.11), and cv2 is the same cv-qualification as, or greater cv-qualification than, cv1. Then null member pointer value(4.11) is converted to the null member pointer value of the destination type. If class B contains the original member, or is a base or derived class of the class containing the original member, the resulting pointer to member points to the original member. Otherwise, the result of the cast is undefined. [Note: although class B need not contain the original member, the dynamic type of the object on which the pointer to member is dereferenced must contain the original member; see 5.5. — end note ]

, утверждает, что явное преобразование с использованием static_cast из decltype(&Child::vfoo) в decltype(&Base::vfoo) также может быть допустимым. Тогда юридические броски друг с другом в этом случае

void (Child::*pb)() = &Base::vfoo;
void (Base ::*pc)() = static_cast<void(Base::*)()>(&Child::vfoo);

и это static_cast означает, что типы &Base::vfoo и &Child::vfoo отличаются друг от друга без какого-либо явного приведения.)

OTOH, поскольку Base::vbar не переопределяется Child, тип decltype(&Child::vbar) — void (Base::*)(), и то же самое с decltype(&Base::vbar). Таким образом

std::is_same<decltype(&Base::vbar) , decltype(&Child::vbar)>::value

это true.

(Кажется, что 5.3.1 Унарные операторы [expr.unary.op] / 3 из n3337,

3. The result of the unary & operator is a pointer to its operand. The operand shall be an lvalue or a qualified- id. If the operand is a qualified-id naming a non-static member m of some class C with type T, the result has type “pointer to member of class C of type T” and is a prvalue designating C::m. Otherwise, if the type of the expression is T, the result has type “pointer to T” and is a prvalue that is the address of the designated object (1.7) or a pointer to the designated function. [ Note: In particular, the address of an object of type “cv T” is “pointer to cv T”, with the same cv-qualification. — end note ] [ Example:

   struct A { int i; };
   struct B : A { };
   ... &B::i ...       // has type int A::*
   

   — end example ]

, заявляет об этом поведении. Интересное обсуждение этого абзаца также найдено здесь.)

Таким образом, мы можем проверить, переопределена ли каждая функция-член, используя decltype(&Base::...), decltype(&Child::...) и std::is_same, следующим образом:

Живая ДЕМО (GCC/Clang/ICC/VS2017)

// Won't fire.
static_assert(!std::is_same<decltype(&Base::foo) , decltype(&Child::foo)> ::value, "oops.");

// Won't fire.
static_assert( std::is_same<decltype(&Base::bar) , decltype(&Child::bar)> ::value, "oops.");

// Won't fire.
static_assert(!std::is_same<decltype(&Base::vfoo), decltype(&Child::vfoo)>::value, "oops.");

// Won't fire.
static_assert( std::is_same<decltype(&Base::vbar), decltype(&Child::vbar)>::value, "oops.");

Кстати, мы также можем определить следующий макрос, чтобы сделать это проще:

#define IS_OVERRIDDEN(Base, Child, Func)                                 \
(std::is_base_of<Base, Child>::value                                     \
 && !std::is_same<decltype(&Base::Func), decltype(&Child::Func)>::value)

что тогда давайте напишем

static_assert( IS_OVERRIDDEN(Base, Child, foo) , "oops."); // Won't fire.
static_assert(!IS_OVERRIDDEN(Base, Child, bar) , "oops."); // Won't fire.
static_assert( IS_OVERRIDDEN(Base, Child, vfoo), "oops."); // Won't fire.
static_assert(!IS_OVERRIDDEN(Base, Child, vbar), "oops."); // Won't fire.