Are there any resources on how to identify problems that could best be solved with templates?

Question

I decided to improve my knowledge in template meta-programming. I know the syntax and rules and been playing with counteless examples from online resources.

I understand how powerful templates can be and how much compile time optimization they can provide but I still cant "think in templates", I can't seem to know by myself if a certain problem could be best solved with templates and if it can, how to adapt that problem to templates.

Is there some kind of online resource or book that teaches how to identify problems that could best be solved with templates and how to adapt that problem?

Answer 1

Books:

Modern C++ design

C++ Template Metaprogramming

Being familiar with recursion and functional programming is a huge plus, as that's what a lot of tmp involves. It's turing complete and so essentially anything is possible, although usually it boils down to applying pure functions to constants or generating types from other types.

Warning: tmp is an ugly monster that turns nice code into spaghetti. The more you use it the less you will like C++. It is an evil thing.

Answer 2

Learn Haskell or some other pure functional language (Lisp, Scheme, OCaml to name a few, you can find more on Wikipedia).

Considering Haskell, you can find more information about it's metaprogramming facilities here.

Template programming follow much the same rules actually.

Answer 3

Just because you can do something with templates doesn't mean you should. Practically speaking unless when you are designing you think this is an awesome job for templates, its probably better to not use them. if you think too much in templates you just create insanely abstracted code that is just as bad as a single giant function.

Answer 4

Keep in mind that templates being the best solution is very rare. I've only defined my own once in the last 5 years, and my peers that reviewed that code had never done it. The cases where templates make a lot of sense have mostly already been implemented in standard libraries.

For generic programming, the thing to look out for is that you are copying and pasting functions to make only minor changes, like in constants or types, and can't figure out a clean way to use something like inheritance or function parameters to avoid repeating yourself.

One fairly common way templates are used is for type safety, if you have types that behave the same, but for whatever reason you don't want them accidentally mixed up.

For compile time calculation using templates, the thing to look out for is resource-intensive calculations where all its inputs are known at compile time, but where different constant inputs are used in different places throughout the code. However, keep in mind this will slow down your compiles every single time, so often it is preferable to just hard code the results manually, if they don't change very often.

Some advocates use templates for micro-optimizations like avoiding virtual table lookups using static polymorphism, or for loop unrolling, but in my opinion the complexity usually outweighs performance gains unless your code is very performance-critical.

Answer 5

Basically, there are several good reasons to use templates :

1. You have a function or a class that has the same functionality for different types. Good example of good templates use is the boost library
2. you want to use static polymorphism, and get compile errors, instead of run-time errors
3. you want to get a specific behavior depending on some static parameters. For example, boost::type_traits provides very good examples.

Answer 6

You should definitely look into templates in C++! This will greatly help you to understand topics like Design Patterns and Generic Programming. Do compare them with what other languages offer you. In precise you should use templates particularly in the following scenarios:

1. Generalization & Code Reuse
2. Flexibility
3. Time & Budget Constraints
4. Lack of expertise for a certain task

Here is a good online resource for you: http://en.wikipedia.org/wiki/Generic_programming#Templates_in_C.2B.2B

Answer 7

A simple indicator of when a template would improve your code, is when you see that your code is frequently requiring you to cast an object to a different type. An example I found in my own Java code, which triggered me to convert an existing method signature to a template:

    public MsgBase getLastSentMessage(Class<? extends MsgBase> msgBaseClass)

My client code always looked like this:

    OrderResponse response = (OrderResponse) getLastSentMessage(OrderResponse.class);

and whenever I used that method, I had to cast the result to the correct subclass of the MsgBase type. The improved method signature was:

    public <T extends MsgBase> T getLastSentMessage(Class<T> clazz)

Now the client code was:

     OrderResponse response = getLastSentMessage(OrderResponse.class);

So to summarize, if you find yourself doing a lot of casting which seems unnecessary, you may have a good case where a template will clean up your code.

Update: a better way to generalize the above statement:

When your source class will be used by objects of many different types, and the source class can interact with those types at a higher (more abstract) level, but your client classes want to interact with specific subtypes, that is a case for using templates. (Container/List classes being the well-known example).

Answer 8

Just today, I used templates to implement a Finite State Machine to lex some input. Expression templates are extremely powerful tools for implementing code concepts like that- they run like hand-optimized C++ and are obscenely fast, yet very generic and very easy to write.

Generally speaking, templates make the most sense when implementing generic algorithms. If you're not implementing a generic algorithm, they don't make that much sense.

Answer 9

The most common uses of templates are as follows:

std::vector<int> vec;
std::map<int, float> mymap;

Then next common example is:

template<class T>
class MyArray {
public:
   virtual T get(int i) const=0;
};

Together with this kind of usage:

class ArrayImpl : public MyArray<float> {
public:
     float get(int i) const { }
};

That one showed important part of templates, which is type substitution -- T is replaced with float type in both places where it is used.