是否可以从超类实现中调用子类虚拟函数？

Question

#include <iostream>

using namespace std;

class Parent
{
public:
    Parent() {}
    virtual void foo() { cout << "My favorite song is:"; bar(); }
    virtual void bar() {}
};

class Child : public Parent
{
public:
    Child() : Parent() {}
    virtual void bar() { cout << "Singing in the Rain"; }
    void baz() { Parent::foo(); }
};

int main()
{
      Child().baz(); // Outputs "My favorite song is: Singing in the Rain"
      return 0;
}

The answer is YES. The above code works as expected.

Answer 1

Is it possible to call a subclass virtual function from within superclass implementation?

It is certainly possible. But you need to actually establish that inheritance relationship. For instance:

class Child : public Parent
//          ^^^^^^^^
//          For instance...
{
public: // Make at least baz() accessible from the outside
    // ...
}; // <== And don't forget the semicolon here

And you also need to give member functions in the base class proper accessibility if they have to be invoked by Child :

class Parent
{
public: // <== For instance, you could make the member functions public
    virtual void foo() { cout << "My favorite song is:"; bar(); }
    virtual void bar() {}
}; // <== Do not forget this

For a complete example, see this live demo .

Answer 2

Is it possible to call a subclass virtual function from within superclass implementation?

Yes, but beware when doing this from within the constructors and destructor, since the type of the object evolves as different constructors/destructors complete. In particular during the execution of the Parent constructor/destructor, the type of the object is Parent regardless of the type of the whole object being constructed.

There are a couple of smells in the code (other than the obvious syntactic errors that the compiler will catch and the lack of inheritance). For example, foo is a virtual function in the base, but in the implementation of Child::baz you are explicitly calling that override (ie disabling dynamic dispatch), which might be intentional or not (you could just call foo() ).