Question

If I want to make a class adaptable, and make it possible to select different algorithms from the outside — what is the best implementation in C++?

I see mainly two possibilities:

• Use an abstract base class and pass concrete object in
• Use a template

Here is a little example, implemented in the various versions:

Version 1: Abstract base class

class Brake { public: virtual void stopCar() = 0;   };  class BrakeWithABS : public Brake { public: void stopCar() { ... } };  class Car {   Brake* _brake; public:   Car(Brake* brake) : _brake(brake) { brake->stopCar(); } }; 

Version 2a: Template

template<class Brake> class Car {   Brake brake; public:   Car(){ brake.stopCar(); } }; 

Version 2b: Template and private inheritance

template<class Brake> class Car : private Brake {   using Brake::stopCar; public:   Car(){ stopCar(); } }; 

Coming from Java, I am naturally inclined to always use version 1, but the templates versions seem to be preferred often, e.g. in STL code? If that’s true, is it just because of memory efficiency etc (no inheritance, no virtual function calls)?

I realize there is not a big difference between version 2a and 2b, see C++ FAQ.

Can you comment on these possibilities?

Answer 1

This depends on your goals. You can use version 1 if you

• Intend to replace brakes of a car (at runtime)
• Intend to pass Car around to non-template functions

I would generally prefer version 1 using the runtime polymorphism, because it is still flexible and allows you to have the Car still have the same type: Car<Opel> is another type than Car<Nissan>. If your goals are great performance while using the brakes frequently, i recommend you to use the templated approach. By the way, this is called policy based design. You provide a brake policy. Example because you said you programmed in Java, possibly you are not yet too experienced with C++. One way of doing it:

template<typename Accelerator, typename Brakes> class Car {     Accelerator accelerator;     Brakes brakes;  public:     void brake() {         brakes.brake();     } } 

If you have lots of policies you can group them together into their own struct, and pass that one, for example as a SpeedConfiguration collecting Accelerator, Brakes and some more. In my projects i try to keep a good deal of code template-free, allowing them to be compiled once into their own object files, without needing their code in headers, but still allowing polymorphism (via virtual functions). For example, you might want to keep common data and functions that non-template code will probably call on many occasions in a base-class:

class VehicleBase { protected:     std::string model;     std::string manufacturer;     // ...  public:     ~VehicleBase() { }     virtual bool checkHealth() = 0; };   template<typename Accelerator, typename Breaks> class Car : public VehicleBase {     Accelerator accelerator;     Breaks breaks;     // ...      virtual bool checkHealth() { ... } }; 

Incidentally, that is also the approach that C++ streams use: std::ios_base contains flags and stuff that do not depend on the char type or traits like openmode, format flags and stuff, while std::basic_ios then is a class template that inherits it. This also reduces code bloat by sharing the code that is common to all instantiations of a class template.

Private Inheritance?

Private inheritance should be avoided in general. It is only very rarely useful and containment is a better idea in most cases. Common case where the opposite is true when size is really crucial (policy based string class, for example): Empty Base Class Optimization can apply when deriving from an empty policy class (just containing functions).

Read Uses and abuses of Inheritance by Herb Sutter.