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

On the positive side, C++ templates:

• Allow for generalization of type

• Decrease the amount of redundant code you need to type

• Help to build type-safe code

• Are evaluated at compile-time

• Can increase performance (as an alternative to polymorphism)

• Help to build very powerful libraries

On the negative side:

• Can get complicated quickly if one isn't careful

• Most compilers give cryptic error messages

• It can be difficult to use/debug highly templated code

• Have at least one syntactic quirk ( the >> operator can interfere with templates)

• Help make C++ very difficult to parse

All in all, careful consideration should be used as to when to use templates.

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.

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.