Templates in C++ - Pros and Cons

Sergey Chepurin

Rate me:

4.68/5 (17 votes)

3 Dec 2011CPOL5 min read

88.2K

Advantages and drawbacks of using templates in C++ projects

Introduction to C++ Templates - Pros and Cons

Once upon a time, I decided to collect and organize all the advantages and drawbacks you may experience when using templates in C++.

Advantages

C++ templates enable you to define a family of functions or classes that can operate on different types of information.

Use templates in situations that result in duplication of the same code for multiple types.
For example, you can use function templates to create a set of functions that apply the same algorithm to different data types.
You can also use class templates to develop a set of typesafe classes.
Templates are sometimes a better solution than C macros and void pointers,
and they are especially useful when working with collections (one of the main uses for templates in MFC) and smart pointers (from MSDN).
A. Stepanov (the creator of STL) notes that some things that seem trivial using templates (such as equality operator, for example) are very difficult to implement with conventional OO techniques such as inheritance and polymorphism.
Because their parameters are known at compile time, template classes are more typesafe, and could be preferred over run-time resolved code structures (such as abstract classes). There are some modern techniques that can dramatically reduce code bloat when using templates. Note that these techniques are very complex either.
Often, the main reason to use templates in combination with STL – it can drastically reduce development time.

Disadvantages

Historically, some compilers exhibited poor support for templates. So, the use of templates could decrease code portability.
Many compilers lack clear instructions when they detect a template definition error. This can increase the effort of developing templates, and has prompted the development of Concepts for possible inclusion in a future C++ standard.
Since the compiler generates additional code for each template type, indiscriminate use of templates can lead to code bloat, resulting in larger executables. For example, used in Adobe products "… GIL (Generic Image Library) implements type generators.
One of these generators generates all image types that are combinations of given sets of color spaces and channels.
This code defines any image t to be one of 4×3×2×2 = 48 possible image types. It can have any of the four listed color spaces, any of the three listed channel depths, it can be interleaved or planar and its pixels can be adjacent or non-adjacent in memory.
The above code generates 48 × 48 = 2304 instantiations. Without any special handling, the code bloat will be out of control."
See Efficient Run-Time Dispatching in Generic Programming with Minimal Code Bloat, 2004.
Because a template by its nature exposes its implementation, injudicious use in large systems can lead to longer build times.
It can be difficult to debug code that is developed using templates. Since the compiler replaces the templates, it becomes difficult for the debugger to locate the code at runtime.
Templates are in the headers, which require a complete rebuild of all project pieces when changes are made.
No information hiding. All code is exposed in the header file. No one library can solely contain the code (from Wikipedia).
Though STL itself is a collection of template classes, templates are not used to write conventional libraries.
The libraries of templates are header-only: the library code is included in and compiled with the user's code.
Though, this makes installation and usage of the libraries relatively easy.

In The C++ Programming Language (3rd Edition), B.Stroustrup presents over 20 factors to take into account when programming templates.
Many of them have to do with ensuring that your code is reliable for all input classes, and maintainable.
B. Stroustrup recognizes these pitfalls:

The ease with which unmaintainable "spaghetti code" can be generated
Automatically generated source code can become overwhelmingly huge
Compile-time processing of templates can be extremely time consuming
Debugging is not intuitive for most programmers
Context dependencies can be difficult to diagnose and even harder to correct (from comments here)

And here is B. Stroustrup's more recent view on templates usage:

Prefer a template over derived classes when run-time efficiency is at a premium
Prefer derived classes over a template if adding new variants without recompilation is important
Prefer a template over derived classes when no common base can be defined
Prefer a template over derived classes when built-in types and structures with compatibility constraints are important

See Joint strike fighter air vehicle C++ coding standards, December 2005.

In sharp contrast to the claim that templates cause code bloat, it so happens that templates can be used to save code space.
C++ compiler is not allowed to generate code for an unused template function. This implies that if a program uses only 3 of a template class’ 7 member functions, only those three functions will occupy space in memory. The equivalent optimization for non-template classes is not common (the standard doesn’t require it) and extremely hard to achieve for virtual functions.

See Abstraction and the C++ machine model, B. Stroustrup, 2004.