#include using namespace std; /********************************************************** * See comments inside main() function **********************************************************/ class Car { public: virtual void start()=0; virtual void drive()=0; }; class Bmw : public Car { public: Bmw(){} virtual ~Bmw(){} virtual void start() { cout << "BMW starts.." << endl; } virtual void drive() { cout << "BMW drives.." << endl; } }; class Audi : public Car { public: Audi(){} virtual ~Audi(){} virtual void start() { cout << "Audi starts.." << endl; } virtual void drive() { cout << "Audi drives.." << endl; } }; /********************************************************** * See comments inside main() function **********************************************************/ template class AutoPilot : public U { public: AutoPilot(){} virtual ~AutoPilot(){} void start() { cout << "Autopilot lets the "; U::start(); } void drive() { cout << "Autopilot lets the "; U::drive(); } }; int main() { cout << "Cars ready to roll..." << endl; /****************************************************************** * This is the typical use case where we have an abstract base class * class 'Car' and 2 derived classes (Bmw & Audi), which we will use * polymorphically. *******************************************************************/ Car* cars[2] = {new Bmw, new Audi}; for(int i = 0; i < 2; i++) { cars[i]->start(); cars[i]->drive(); } for(int i = 0; i < 2; i++) delete cars[i]; /****************************************************************** * Now imagine the use case where we are a autopilot provider. We want * to extend all classes derived from Car, so that they can be controlled * by our Autopilot. We can obviously extend each type individually like * this: * class AutoPilotedBmw : public Bmw{...}; * class AutoPilotedAudi : public Audi{...}; * ..etc... * But this does not scale well if there are many such classes, since the * Autopilot functionaility must be repeated for every type. * * The AutoPilot template class is a 'generic' solution for this kind of * problem. It can 'hook' below any class derivation chain derived from * 'Car' by also implementing the pure virtual functions declared in Car. * It thus overrides the start() and drive() functions of its parent class, * which can be any Car-derived class - which it receives is its sole template * argument. * * Note this technique may appear to go against the dictum of inheritance * being a 'is a' relationship, but this is not the case. The way to view * the class is a 'Autopiloted-Bmw', which is still a Bmw which is still a Car. * So all is good! *******************************************************************/ Car* autoCars[2] = {new AutoPilot, new AutoPilot}; for(int i = 0; i < 2; i++) { autoCars[i]->start(); autoCars[i]->drive(); } for(int i = 0; i < 2; i++) delete autoCars[i]; /****************************************************************** * Final point on this technique: * It relies on the classes implementing Car (Bmw, Audi) to keep their start() * and drive() methods virtual, to allow Autopilot to override them polymorphically. * In the case where these methods are non-virtual, the same can be achieved, but * with a slight increase of complexity (the template requires 2 template * arguments). I will show this method as a separate post. *******************************************************************/ return 0; }

GenericInheritanceByTemplate