Why override under private inheritance?

Question

class Base {
public:
   virtual void f() {}
};

class Derived : private Base {
public:
   void f() override {}
};

My question is there any use to such override? Private inheritance implies that you can not store Derived in Base pointer and thus it will never be needed to dynamically dispatch f to the correct type.

Hint: Some method in `Base` calls `this->f()`. Does it call `Base::f()` or `Derived::f()`? — dhke, Aug 19 '16 at 08:33
you can use C-style cast to store `Derived*` in `Base*`, actually. — Ven, Aug 19 '16 at 08:35
@Ven: You can use C-style casts to store almost anything into anything. You won't always get defined behavior, though ;-). — dhke, Aug 19 '16 at 08:35
well, that's the one use-case for a C-style cast rather than a `reinterpret_cast`. — Ven, Aug 19 '16 at 08:36
It seems like a wonderfully useful feature for coding interviews, no? — Ami Tavory, Aug 19 '16 at 08:37
@AmiTavory I have 2 interviews next week and this popped into my head lastnight =) — mkmostafa, Aug 19 '16 at 08:38
This one seems pretty reasonable to me: http://stackoverflow.com/a/676725/4885321 — alagner, Aug 19 '16 at 08:40
@alagner I don't see where the function "DoSomething" is dynamically dispatched in your link :) — mkmostafa, Aug 19 '16 at 08:43

ralfg · Accepted Answer · 2016-08-19T09:22:07.250

7

Just one example: A function of Derived::f1() can call a (public or protected) functions of Base::f2(), which in turn can call f(). In this case, dynamic dispatch is needed.

Here is an example code:

#include "iostream"
using namespace std;

class Base {
  public:
    virtual void f()  { 
      cout << "Base::f() called.\n"; 
    }
    void f2() { 
      f(); // Here, a dynamic dispatch is done!
    }
};

class Derived:private Base {
  public:
    void f() override { 
      cout << "Derived::f() called.\n"; 
    }
    void f1() { 
      Base::f2(); 
    }
};

int main() {
  Derived D;
  D.f1();
  Base    B;
  B.f2();
}

Output:

Derived::f() called
Base::f() called

edited Aug 19 '16 at 09:22

answered Aug 19 '16 at 08:37

ralfg

552
2
11

Can you provide an example or complete the example above please? – mkmostafa Aug 19 '16 at 08:42
In your example if I understood correctly, Base::f will always be called. – mkmostafa Aug 19 '16 at 08:58
@mkmostafa: OK, I added an example. Just compile it and convince yourself. – ralfg Aug 19 '16 at 09:22
basically inside f1 instead of calling f directly you forwarded the call to the base to invoke the dynamic dispatcher – mkmostafa Aug 19 '16 at 09:34

Why override under private inheritance?

1 Answers1