具有C ++实现的纯虚函数

Question

I'm aware that one can make implementation for pure virtual function in base class, as a default implementation. But i don't quite understand the code below.

class A {
public:
    virtual void f1() = 0;
    virtual void f2() = 0;
};
void A::f1(){
    cout << "base f1" << endl;
    f2();
}
void A::f2(){
    cout << "base f2" << endl;
}

class B: public A {
public:
    void f1() { A::f1(); }
    void f2() { cout << "derived f2" << endl; }
};

int main(){
    B b;
    b.f1();
}

Why does the B::f1() calls B::f2() instead of A::f2. I know it will behave this way, but why? what basic knowledge i have missed.

another question, did implementation for pure virtual function in base class make the pure(=0) unnecessary?

Answer 1

This is the behaviour the C++ standard defines for virtual functions: call the version of the most derived type available.

Sure, for normal objects, the most derived type is the one of the object itself:

B b;
b.f1(); // of course calls B's version

The interesting part is if you have pointers or references:

B b;
A& ar = b;
A* ap = &b;

// now both times, B's version will be called
ar.f1();
ap->f1();

The same occurs inside f1, actually, you do implicitly:

this->f2(); // 'this' is a POINTER of type A* (or A const* in const functions).

There's a phenomenon when this does not occur (the example below requires a copy constructor):

B b;
A a = b; // notice: not a pointer or reference!
A.f1();  // now calls A's version

What actually happens here is that only the A part of b is copied into a and the B part is dropped, so a actually is a true, non-derived A object. This is called 'object slicing' and is the reason for that you cannot use base objects in eg a std::vector to store polymorphic objects, but need pointers or references instead.

---

Back to virtual functions: If you are interested in the technical details, this is solved via virtual function tables, short vtables. Be aware that this is only a de-facto standard, C++ does not require implementation via vtables (and actually, other languages supporting polymorphism/inheritance, such as Java or Python, implement vtables, too).

For each virtual function in a class there's an entry in its corresponding vtable.

Normal functions are called directly (ie an unconditional branch to the function's address is executed). For virtual function calls, in contrast, we first need to lookup the address in the vtable and only then we can jump to the address stored there.

Derived classes now copy the vtables of their base classes (so initially these contain the same addresses than the base class tables), but replace the appropriate addresses as soon as you override a function.

By the way: You can tell the compiler not to use the vtable, but explicitly call a specific variant:

B b;
A& a = b;
a.A::f1(); // calls A's version inspite of being virtual,
           // because you explicitly told so
b.A::f1(); // alike, works even on derived type