Explicitly stop late binding

Question

If we create an object pointer to base class class which points to its child class object then we use virtual key word for late binding So.,in case of late binding,, our code goes like this :-

#include<iostream>
using namespace std;
struct A{
    virtual void print() {
        cout<<"function1";
    }
};

struct B : public A{
    void print(){
        cout<<"function2";
    } 
};

struct C : public B{
    void print(){
        cout<<"function3";
    } 
};

int main(){
    A* a = new C();
    A* p = new B();
    a->print();
    p->print();
} 

Now my question is : when we use virtual keyword in base class, all the functions of derived classes created in base class will become virtual. In multilevel inheritance, is there any way so that we can stop the function of class c from being virtual?? Any way to break this chain of virtual functions ? Sorry for any mistakes in question but i tried my best.. ☺️☺️

Answer 1

It is not possible to make a function that is already virtual be not virtual in a child class.

Virtuality is a property of the top-level base class, not the child classes. Once a method has been marked as virtual, and pointer to that class must use dynamic dispatch for that function when calling because the pointer could be pointing to a child class that has overridden the behaviour.

Consider this code:

A a;
B b;
C c;

A * ap = &a;
A * bp = &b;
A * cp = &c;

ap->print(); // 'function1'
bp->print(); // 'function2'
cp->print(); // 'function3'

Here, the calls to print cannot tell which function to call at compile time, they absolutely must use dynamic dispatch.

However, you can make C::print behave like A::print

struct C : public B {
    void print() {
        A::print();
    }
};

Which results in:

ap->print(); // 'function1'
bp->print(); // 'function2'
cp->print(); // 'function1'

And if the behaviour of A::print() changes, C::print() mirrors those changes.

This will still be overridable though, unless you use the final keyword as outlined below.

---

Original answer:

I believe you are looking for the final specifier. It's only available as of C++11 though.

To quote en.cppreference's page about the final specifier:

When used in a virtual function declaration or definition, final ensures that the function is virtual and specifies that it may not be overridden by derived classes. The program is ill-formed (a compile-time error is generated) otherwise.

And a variation of the example they give, demonstrating the solution to your problem:

struct A
{
    virtual void foo();
};

struct B : A
{
    void foo() final; // B::foo is overridden and it is the final override
};

struct C : B
{
    void foo() override; // Error: foo cannot be overridden as it's final in B
};