class B
{
   virtual void do_f();    // private-функция

public:
   void f() { do_f(); }    // публичный интерфейс доступа
};

struct D : public B
{
   void do_f() override;   // переназначает B::do_f
};

int main()
{
   D d;
   B* bp = &d;
   bp->f();                // внутри вызывается D::do_f();
}

struct A { virtual void f(); };     // A::f виртуальная

struct B : A { void f(); };         // B::f переопределяет A::f в классе B

struct C : virtual B { void f(); }; // C::f переопределяет A::f в классе C

struct D : virtual B {};   // D не предоставляет свое переопределение, так что в классе D
                           // конечным переопределителем будет B::f

struct E : C, D
{  // E не предоставляет свое переопределение, так что в классе E
   // конечным переопределителем будет C::f
   using A::f;    // это не декларация функции, а простое разрешение видимости A::f
};

int main()
{
   E e;
   e.f();      // virtual-вызов, запускающий C::f, конечный переопределитель в e
   e.E::f();   // non-virtual вызов, запускающий A::f, которая видна в E
}

struct A
{
   virtual void f();
};

struct VB1 : virtual A
{
   void f();   // переопределяет A::f
};

struct VB2 : virtual A
{
   void f();   // переопределяет A::f
};

// struct Error : VB1, VB2

//{

//   // Тут ошибка: у A::f два конечных переопределителя

//   void f();

//};

struct Okay : VB1, VB2
{
   void f(); // OK: это конечный переопределитель для A::f
};

struct VB1a : virtual A {}; // не декларируется переопределитель

struct Da : VB1a, VB2
{
   // в Da конечным переопределителем A::f будет VB2::f
};

struct B
{
   virtual void f();
};

struct D : B
{
   void f(int);   // D::f скроет B::f (не совпадающий список параметров)
};

struct D2 : D
{
   void f();      // D2::f переопределит B::f (при этом не имеет значения,
                  // что B::f вне области видимости)
};

int main()
{
   B b;   B& b_as_b   = b;
   D d;   B& d_as_b   = d;    D& d_as_d = d;
   D2 d2; B& d2_as_b  = d2;   D& d2_as_d = d2;
 
   b_as_b.f();    // вызовет B::f()
   d_as_b.f();    // вызовет B::f()
   d2_as_b.f();   // вызовет D2::f()
 
   d_as_d.f();    // Ошибка: система разрешения имен в D найдет только f(int)
   d2_as_d.f();   // Ошибка: система разрешения имен в D найдет только f(int)
}

struct B
{
   virtual void f(int);
};

struct D : B
{
   virtual void f(int) override;    // OK, D::f(int) переопределяет B::f(int)
   virtual void f(long) override;   // Ошибка: f(long) не переопределяет B::f(int)
};

struct B
{
   virtual void f() const final;
};

struct D : B
{
   void f() const;   // Ошибка: D::f попыталась переопределить B::f
};

struct A
{
   virtual void f() requires true;  // Ошибка: virtual-функция с ограничением
};

class B {};
 

struct Base
{
   virtual void vf1();
   virtual void vf2();
   virtual void vf3();
   virtual B* vf4();
   virtual B* vf5();
};
 

class D : private B
{
   friend struct Derived;  // в Derived, класс B это доступная база для D
};
 

class A;    // предварительно декларированный класс с неполным определением типа.
 

struct Derived : public Base
{
   void vf1();       // virtual, переопределяет Base::vf1()
   void vf2(int);    // non-virtual, скрывает Base::vf2()

//   char vf3();       // Ошибка: переопределяет Base::vf3, но отличается

//                     // и не ковариантный возвращаемый тип
   D* vf4();      // переопределяет Base::vf4() и имеет ковариантный возвращаемый тип

//   A* vf5();         // Ошибка: у A неполное определение типа
};
 

int main()
{
   Derived d;
   Base& br = d;
   Derived& dr = d;
 
   br.vf1();         // вызовет Derived::vf1()
   br.vf2();         // вызовет Base::vf2()

//   dr.vf2();         // Ошибка: vf2(int) скрывает vf2()
 
   B* p = br.vf4();  // вызовет Derived::vf4() и преобразует результат в B*
   D* q = dr.vf4();  // вызовет Derived::vf4() и не сделает преобразование
                     // результата в B*
}

class Base
{

public:
   virtual ~Base() { /* освобождает ресурсы базового класса Base */ }
};
 

class Derived : public Base
{
   ~Derived()     { /* освобождает ресурсы производного класса Derived */ }
};
 

int main()
{
   Base* b = new Derived;
   delete b;   // Поскольку базовый деструктор Base::~Base() виртуальный,
               // он вызывается Derived::~Derived(). ~Derived() освобождает
               // ресурсы производного класса и затем вызывается Base::~Base(),
               // следуя обычному порядку удаления объектов.
}

struct V
{
   virtual void f();
   virtual void g();
};
 

struct A : virtual V
{
   virtual void f();    // A::f это конечный переопределитель V::f в классе A
};

struct B : virtual V
{
   virtual void g();    // B::g это конечный переопределитель V::g в классе B
   B(V*, A*);
};

struct D : A, B
{
   virtual void f();    // D::f это конечный переопределитель V::f в классе D
   virtual void g();    // D::g это конечный переопределитель V::g в классе D
 
   // замечание: A инициализируется перед B
   D() : B((A*)this, this) 
   {
   }
};
 

// Конструктор B вызывается из конструктора D
B::B(V* v, A* a)
{
   f();     // virtual-вызов V::f (хотя у D есть конечный переопределитель, D не существует)
   g();     // virtual-вызов B::g, который конечный переопределитель в B
 
   v->g();  // у v тип V, у которого базовый тип B, и виртуальный вызов запустит B::g,
            // как и ранее
 
   a->f();  // поскольку тип A не базовый для B, он принадлежит к другой ветви иерархии.
            // Попытка виртуального вызова через эту ветвь приведет к неопределенному
            // поведению даже когда A был уже полностью сконструирован в этом случае
            // (он был сконструирован перед B, поскольку появляется перед B в списке
            // базовых классов D). На практике виртуальный вызов A::f будет пытаться
            // использовать таблицу виртуальных функций B, поскольку это то, что
            // активно в время конструирования B).
}