通过派生类虚方法调用基类虚方法

Question

In C++ - take a case where derived class deriving from a base class and there is a virtual method in base class which the derived class is overriding. Could someone tell me a real life scenario where the derived class version of the virtual function might require to call the base class version of the virtual function?

Example,

class Base
{
public:
    Base() {}
    virtual ~Base() {}
    virtual void display() { cout << "Base version" << endl; }
};

class Derived : public Base
{
public:
    Derived() {}
    virtual ~Derived() {}
    void display();
};

void Derived::display()
{
    Base::display();  // a scenario which would require to call like this?
    cout << "Derived version" << endl;
}

Answer 1

You do that every time when you also need base class behavior but don't want (or can't) reimplement it.

One common example is serialization:

void Derived::Serialize( Container& where )
{
    Base::Serialize( where );
    // now serialize Derived fields

}

you don't care how base class is serialized, but you definitely want it to serialize (otherwise you lose some data), so you call the base class method.

Answer 2

You can find lots of real-life examples in MFC. For. eg

CSomeDialog::OnInitDialog()
{
  CDialogEx::OnInitDialog(); //The base class function is called.
  ----
  ----- 
}

Answer 3

Yes, sometimes this is done in serialization:

class A{
   int x;
public:
   A () : x(0) {}
   virtual void out( Output* o ) {
      o->write(x);
   }
   virtual void in( Input* i ) {
      i->read(&x);
   }
}

class B : public A{
   int y;
public:
   B () : y(0) {}
   virtual void out( Output* o ) {
      A::out(o);
      o->write(y);
   }
   virtual void in( Input* i ) {
      A::in(i);
      i->read(&y);
   }
}

This is done because you want to read/write data both for the parent class as well as for your derived class.

This is a real-life example as to when the derived class must also call the base class functionality as well as add something more to it.

Answer 4

In an implementation of the GoF State Pattern , when a substate has an exit() function and the superstate has too. You are required to execute the substate exit() first, then the superstate's