Will a method be called virtually even if no sub-class overrides it?

Question

Imagine you have the following classes:

class A {
  public:
    virtual void print()           { printf("A\n"); }
};
class B : public A {
  public:
    virtual void print() override  { printf("B\n"); }
};
class C : public B {
    // no override of print
};

And now if you create an instance of B and call print:

B * b = new B;
b->print();

Will this method be called virtually? In other words, will the exact method to be called determined at compile-time or run-time?

Theoretically it can be determined at compile-time, because we know, that none of sub-classes of B overrides that method, so no matter what I assign into pointer to B B * b = new C; b->print();, it will always call B::print().

Does the compiler know it too and save me from unnecessary overhead of the virtual call?

Answer 1

Theoretically it can be determined at compile-time, because we know, that none of sub-classes of B overrides that method

You cannot determine this at compile time in general case, because C++ compiler deals with one translation unit at a time. A class from a different translation unit, say, class D : public B could override the method. However, the compiler may have no visibility into the translation unit of class D at the time the call to b->print() is translated, so the compiler must assume a virtual call.

In order to address this shortcoming C++11 introduced final keyword, which lets programmers tell the compiler that there would be no further overrides down from this level of inheritance hierarchy. Now the compiler can optimize out the virtual call, and also enforce the requirement of no further overrides.

Answer 2

Regarding

” Theoretically it can be determined at compile-time, because we know, that none of sub-classes of B overrides that method, so no matter what i assign into pointer to B B * b = new C; b->print();, it will always call B::print().

Yes.

However, whether the compiler will do this optimization depends entirely on the compiler, what it knows, and what you tell it to do.

What the compiler knows depends on many factors, such as

• Are there classes defined in multiple translation units that are compiled separately?

• Are you using global optimization?

• Are you perhaps using the keyword final to inform the compiler?

With your specific example,

B * b = new B;
b->print();

where print is virtual, I would feel pretty confident that it would be called non-virtually regardless of compiler, because here the compiler knows what b refers to. Let's check.

OK, with MinGW g++ 5.1 and option -O2 (I didn't try anything else) the call is compiled down to a direct call of puts, even bypassing the printf.