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?