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.
References
- Templates, MSDN, Visual Studio 2010
- Templates (programming), Wikipedia
- Pros and cons of using C++ templates, May 22, 2002
- Interviews Alex Stepanov, March 1995 issue of Dr. Dobb's Journal
- Advanced Concepts in C++: Dangerous but Occasionally Useful, March 19, 1996, by Fritz Knabe
- Efficient Run-Time Dispatching in Generic Programming with Minimal Code Bloat, 2004
- Joint strike fighter air vehicle C++ coding standards, December 2005
- Abstraction and the C++ machine model, B. Stroustrup, 2004
- Techniques for Scientific C++, by Todd Veldhuizen, 2000
History
- 29.10.2011 - Initial submission of article
- 03.12.2011 - Article updated
