Применение ключевого слова с использованием чистой виртуальной функции С++

Основываясь на моей первой попытке найти ответ, комментариях и ответе @Oliv, позвольте мне попытаться обобщить все возможные сценарии для объявления using A::memberFct внутри C.

• Функция-член A является виртуальной и переопределяется B.
• Функция-член A не является виртуальной и скрыта B
• Функция-член A не является виртуальной и скрыта самим C

Небольшой пример для этих случаев выглядит следующим образом.

struct A {
   virtual void f() {}
   void g() {}
   void h() {}
};

struct B : A {
   void f() override {}
   void g() {}
};

struct C : B {
   using A::f; // Virtual function, vtable decides which one is called
   using A::g; // A::g was hidden by B::g, but now brought to foreground
   using A::h; // A::h is still hidden by C's own implementation
   void h() {}
};

Вызов всех трех функций через интерфейс C приводит к различным вызовам функций:

C{}.f(); // calls B::f through vtable
C{}.g(); // calls A::g because of using declarative
C{}.h(); // calls C::h, which has priority over A::h

Обратите внимание, что использование объявлений внутри классов имеет ограниченное влияние, т. е. они изменяют поиск имени, но не виртуальную отправку (первый случай). Является ли функция-член чисто виртуальной или нет, это поведение не меняет. Когда функция базового класса скрыта функцией ниже по иерархии наследования (второй случай), поиск настраивается таким образом, что функция, подлежащая объявлению использования, имеет приоритет. Когда функция базового класса скрыта функцией самого класса (третий случай), реализация самого класса имеет приоритет, см. cppreference:

Если в производном классе уже есть член с таким же именем, списком параметров и квалификациями, член производного класса скрывает или переопределяет (не конфликтует с ним) член, введенный из базового класса.

В вашем исходном фрагменте C, следовательно, не является абстрактным классом, поскольку только механизм поиска для рассматриваемой функции-члена зависит от использования объявлений, а точки vtable не указывают на чистую реализацию виртуальной функции-члена.

Это связано с тем, что использование объявления не вводит новый член или новое определение. Скорее, он вводит набор объявлений, которые можно найти с помощью поиска по полному имени [namespace.udecl]/1:

Каждый декларатор использования в объявлении использования вводит набор объявлений в декларативную область, в которой появляется объявление использования. Набор объявлений, введенных декларатором использования, находится путем поиска уточненного имени ([basic.lookup.qual], [class.member.lookup]) для имени в деклараторе использования, исключая функции, которые скрыты, как описано ниже.

Это влияет только на сущность(и), найденную(ые) при поиске по уточненному имени. Таким образом, он не влияет на определение последнего переопределения [class.virtual]/2:

[...] Виртуальная функция-член C::vf объекта класса S является окончательным переопределением, если только самый производный класс ([intro.object]), из которого S не является подобъектом базового класса (если таковой имеется) объявляет или наследует другую функцию-член, которая переопределяет vf.

Что имеет другое значение, чем: конечный переопределяющий объект — это объект, обозначенный выражением D::vf, где D — наиболее производный класс, из которого S — подобъект базового класса.

И, как следствие, это не влияет на то, является ли класс абстрактным классом [class.abstract] /4:

class A {
  public :
  void print() {
    std::cout << "\n Class A::print()";
    }
  };

int main() {
  B b;
  C c;        
  b.print() // Class B print ()
  c.print() // Class A print ()
  //Equivalent to:
  c.C::print() // Class A::print()             
  return 0;               
  }

class A {
  public :
  virtual void print() =0;
  };

//Warning arcane: A definition can be provided for pure virtual function
//which is only callable throw qualified name look up. Usualy an attempt
//to call a pure virtual function through qualified name look-up result
//in a link time error (that error message is welcome).
void A::print(){ 
  std::cout << "pure virtual A::print() called!!" << std::endl;
  }

int main() {
  B b;
  C c;        
  b.print() // Class B print ()
  c.print() // Class B print ()
  c.C::print() // pure virtual A::print() called!!
  //whitout the using declaration this last call would have print "Class B print()"              
  return 0;               
  }

Текущая демонстрация