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

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 ou

Templates should be used sparingly.

"Awful to debug" and "hard to read" aren't great arguments against good template uses with good abstractions.

Better negative arguments would go towards the fact that the STL has a lot of "gotchas", and using templates for purposes the STL already covers is reinventing the wheel. Templates also increase link time, which can be a concern for some projects, and have a lot of idiosyncrasies in their syntax that can be arcane to people.

But the positives with generic code reuse, type traits, reflection, smart pointers, and even metaprograms often outweigh the negatives. The thing you have to be sure of is that templates are always used carefully and sparingly. They're not the best solution in every case, and often not even the second or third best solution.

You need people with enough experience writing them that they can avoid all the pitfalls and have a good radar for when the templates will complicate things more than helping.

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.