virtual function in private or protected inheritance

Question

It's easy to understand the virtual function in public inheritance. So what's the point for virtual function in private or protected inheritance?

For example:

class Base {
public:
virtual void f() { cout<<"Base::f()"<<endl;}
};

class Derived: private Base {
public: 

void f() { cout<<"Derived::f()"<<endl;}

};

Is this still called overriding? What's the use of this case? What's the relationship of these two f()?

Thanks!

Answer 1

Private inheritance is just an implementation technique, not an is-a relationship, as Scott Meyers explains in Effective C++:

class Timer {
public:
    explicit Timer(int tickFrequency);
    virtual void onTick() const; // automatically called for each tick
    ...
};

class Widget: private Timer {
private:
    virtual void onTick() const; // look at Widget private data
    ...
};

Widget clients shouldn't be able to call onTick on a Widget, because that's not part of the conceptual Widget interface.

Answer 2

Your f() method is still overridden. This relationship is useful when implementing the Template Method design pattern. Basically, you'd implement common sets of operations in the base class. Those base class operations would then invoke a virtual method, like your f(). If the derived class overrides f(), the base class operations end up calling the derived version of f(). This allows derived classes to keep the base algorithm the same but alter the behavior to suit their needs. Here's a trivial example:

#include <iostream>

using namespace std;

class Base
{
public:
  virtual void f() { cout<<"Base::f()" << endl; }
protected:
  void base_foo() { f(); }
};

class DerivedOne: private Base
{
public: 
  void f() { cout << "Derived::f()" << endl;}
  void foo() { base_foo(); }
};

class DerivedTwo: private Base
{
public: 
  void foo() { base_foo(); }
};

int main()
{
  DerivedOne d1;
  d1.foo();

  DerivedTwo d2;
  d2.foo();
}

Here's the result at run-time:

$ ./a.out 
Derived::f()
Base::f()

Both derived classes call the same base class operation but the behavior is different for each derived class.