17

In many situations, the question doesn't even ask itself, since sometimes inheritance provides necessary features which templates can't provide. For example, when I need to address different types via one base-type (polymorphism), I need to use inheritance.

However, there are some instances where the problem can be solved both with inheritance, as well as templates.

Take for example strategy pattern-like parametrization of certain parts of the code:

One solution of a file-parser could look like this:

class FileParser
{
   //...
   public:
      void Parse(ParsingAlgorithm* p);
   //...
}

void FileParser::Parse(ParsingAlgorithm* p)
{
   m_whatevertypeofvaluesineed = p->Parse(whateverparametersyouneed);
}

where ParsingAlgorithm is an abstract base class, which provides some basic methods and needs to be inherited by whoever likes to implement a specific parser for the FileParser class.

However, the same can easily be achieved using templates:

template <class Parser>
class FileParser
{
   //...
   public:
      void Parse()
      {
           m_whatevertypeofvaluesineed = m_parser.Parse(whateverparametersyouneed);
      }

   private:
      Parser m_parser;
   //...
}

Are there some general rules that I can use to decide whether to use templates or inheritance? Or should I simply use templates wherever possible, in order to avoid run-time overhead of things like virtual functions?

TravisG
  • 2,373
  • 2
  • 30
  • 47
  • somewhat duplicate of [Can CRTP completely replace virtual functionality for smaller designs ?](http://stackoverflow.com/questions/6613779/can-crtp-completely-replace-virtual-functionality-for-smaller-designs) – iammilind Jul 12 '11 at 11:57

4 Answers4

18

If you know during compile-time what objects you're going to manipulate, then static polymorphism with templates is often the fastest way to go, and it produces code that's a little bit more concise (no need for explicit inheritance). It can also be more generic as you're not restricted to a strong class hierarchy.

If you want run-time polymorphism, then you have no choice but to use pointers, inheritance and the slight overhead of virtual functions.

My own opinion:

  • Use templates when possible, it's comfortable
  • Use inheritance to factorise code (but not to have heterogenous collections), but be careful with slicing.
  • Don't worry about the performance issues of virtual calls
  • Sometimes you have no choice and you want hetergenous collections dragging around the pain of using pointers
huitlarc
  • 1,993
  • 2
  • 13
  • 12
Tristram Gräbener
  • 9,601
  • 3
  • 34
  • 50
4

Templates provide compile-time polymorphism as opposed to run-time polymorphism provided by inheritance. I prefer using templates when I can.

This article on Templates and Inheritance explains it in detail.

Ozair Kafray
  • 13,351
  • 8
  • 59
  • 84
3

Templates are generally more performant at runtime, since more work is done at compile time. On the other hand, they can be more complex, thus difficult to write and understand. So, it's best to use them whenever you can and when it doesn't overcomplicate the whole solution.

For your examples, they are not exactly functionally equivalent: first variant allows and requires you to create instance of a parser at runtime, whereas second variant requires the parser to be chosen by the programmer when he writes code.

vines
  • 5,160
  • 1
  • 27
  • 49
-1

My suggestion is to use neither in this case and use separate functions for each file type;

    Stream stream = open(filepath);

    Image image = ParseBMP(stream);
    // ...or
    Image image = ParseJPG(stream);

No need to make things more complicated than they are.

Viktor Sehr
  • 12,825
  • 5
  • 58
  • 90
  • You are right, but my example was just supposed to be a quick example of the type of situation in which the "inheritance vs templates" question might arise. – TravisG Jul 12 '11 at 11:57
  • I don't agree. Using different functions is against the open-close principal http://en.wikipedia.org/wiki/Open/closed_principle – Alessandro Teruzzi Jul 12 '11 at 13:49
  • Never heard about that principal before, but it seems kind of evil to me. – Viktor Sehr Jul 12 '11 at 14:09