What are the good and bad points of C++ templates? [closed]

Answer 1

My 2c are rather negative.

C++ types were never designed to perform compile time calculations. The notion of using types to achieve computational goals is very clearly a hack – and moreover, one that was never sought but rather stumbled upon

..

The reward for using MP in your code is the moment of satisfaction of having solved a hard riddle. You did stuff in 100 lines that would have otherwise taken 200. You grinded your way through incomprehensible error messages to get to a point where if you needed to extend the code to a new case, you would know the exact 3-line template function to overload. Your maintainers, of course, would have to invest infinitely more to achieve the same.

Answer 2

Some people hate templates (I do) because:

• On maintainability pov, the wrong use of templates can have a negative effect ten times stronger than the initial advantage of time they were supposed to bring.
• On optimization pov, compiler optimizations they allow are nothing compared to an optimal algorithm and the use of multi threading.
• On compiling time pov, wrong use of templates can a very negative effect on parsing, compilation and linking phases, when poorly written templated declaration brings tons of useless parasite declarations in each compilation units (here is how 200 lines of code can produce an .obj of 1Mb).

To me templates are like a chainsaw with an integrated flame thrower that can also launch grenades. One time in my life I may have a specific need of that. But most of the time, I'm using a regular hammer and a simple saw to build things and I'm doing a pretty good job that way.

Answer 3

I don't see how they are hard to read. What is unreadable about

vector <string> names;

for example? What would you replace it with?

Answer 4

Templates are a very powerful mechanism which can simplify many things. However to use them properly requires much time and experience - in order to decide when their usage is appropriate.

For me the most important advantages are:

• reducing the repetition of code (generic containers, algorithms)
• reducing the repetition of code advanced (MPL and Fusion)
• static polymorphism (=performance) and other compile time calculations
• policy based design (flexibility, reusability, easier changes, etc)
• increasing safety at no cost (i.e. dimension analysis via Boost Units, static assertions, concept checks)
• functional programming (Phoenix), lazy evaluation, expression templates (we can create Domain-specific embedded languages in C++, we have great Proto library, we have Blitz++)
• other less spectacular tools and tricks used in everyday life:
  • STL and the algorithms (what's the difference between for and for_each)
  • bind, lambda (or Phoenix) ( write clearer code, simplify things)
  • Boost Function (makes writing callbacks easier)
  • tuples (how to genericly hash a tuple? Use Fusion for example...)
  • TBB (parallel_for and other STL like algorithms and containers)
• Can you imagine C++ without templates? Yes I can, in the early times you couldn't use them because of compiler limitations.
• Would you write in C++ without templates? No, as I would lose many of the advantages mentioned above.

Downsides:

• Compilation time (for example throw in Sprit, Phoenix, MPL and some Fusion and you can go for a coffee)
• People who can use and understand templates are not that common (and these people are useful)
• People who think that they can use and understand templates are quite common (and these people are dangerous, as they can make a hell out of your code. However most of them after some education/mentoring will join the group mentioned in the previous point)
• template export support (lack of)
• error messages could be less cryptic (after some learning you can find what you need, but still...)

I highly recommend the following books:

• C++ Templates: The Complete Guide by David Vandevoorde and Nicolai Josuttis (thorough introduction to the subject of templates)
• Modern C++ Design. Generic Programming and Design Patterns Applied by Andrei Alexandrescu (what is the less known way of using templates to simplify your code, make development easier and result in code robust to changes)
• C++ Template Metaprogramming by David Abrahms and Aleksey Gutov (again - different way of using the templates)
• More C++ Idioms from Wikibooks presents some nice ideas.

Answer 5

Good points: powerful; allows you to:

• prescribe compile-time attributes and computation
• describe generic algorithms and datastructures
• do many other things that would otherwise be repetitive, boring, and mistake-prone
• does them in-language, without macros (which can be far more hazardous and obscure!)

Bad points: powerful; allows you to:

• provoke compile-time errors that are verbose, misleading, and obscure (though not as obscure and misleading as macros...)
• create obscure and hazardous misdesigns (though not as readily as macros...)
• cause code bloat if you're not careful (just like macros!)

Templates vastly increase the viable design space, which is not necessarily a bad thing, but it does make them that much harder to use well. Template code needs maintainters who understand not just the language features, but the design consequences of the language features; practically speaking, this means many developer groups avoid all but the simplest and most institutionalized applications of C++ templates.

In general, templates make the language much more complicated (and difficult to implement correctly!). Templates were not intentionally designed to be Turing-complete, but they are anyway -- thus, even though they can do just about anything, using them may turn out to be more trouble than it's worth.

Answer 6

Reusable code is made with template. Its application is in accordance with the profile of each.