Imagine your CPU cache being completely invalidated – in that case before calling virtual function you must load virtual table to your cache first, then check address of the code to jump to, then load function to your cache. Non-virtual function call needs just an address.

If your application has hundreds of classes with thousands of virtual functions being called in random order all over the time, then you’re likely to be experiencing lots of cache misses for your virtual tables.

Hello Hummm,

the problem is less about when you call X::vfun(), but when you call a method of a derived class, i.e. Y::fun() (without the “v”), which in turn should call a virtual method.

Take this updated snippet:

#include
void vfun() {
std::cout < < "::vfun()\n";
}
template struct X {
virtual void vfun() const { std::cout < < "X::vfun()\n"; }
};
template struct Y : public X {
// During compilation, only the global vfun()
// is visible, so this will call ::vfun().
void fun0 () { vfun(); }
//
// This will explitily call X::vfun()
// and inhibit virtual function dispatch.
void fun1 () { X::vfun(); }
//
// Qualifying the call with this makes the call
// to vfun() "dependent", as the type of 'this'
// depends on X, which is not yet known.
// Thus, the compiler will postpone
// name-lookup until Phase 2 of template parsing.
void fun2 () { this->vfun(); }
};
template struct Z : Y {
virtual void vfun() const { std::cout < < "Z::vfun()\n"; }
};
int main () {
Z z;
z.fun0();
z.fun1();
z.fun2();
std::cout < < std::flush;
}

If you are using MSVC, make sure to disable C++ language extensions.

I am maybe too noob in C++, but I didn’t understand your statement “So, if we now call Z::vfun() through a pointer or reference to struct X, we really call X::vfun(), and not the overriden version in Z.”

I understood that C++ calls ::vfun() from Y::fun(); However, compiling your example and executing: X * x = &z; x->vfun(); returns “Z::vfun()n”. Where is the problem?