Most important things about C++ templates… lesson learned

Question

What are most important things you know about templates: hidden features, common mistakes, best and most useful practices, tips...common mistakes/oversight/assumptions

I am starting to implement most of my library/API using templates and would like to collect most common patterns, tips, etc., found in practice.

Let me formalize the question: What is the most important thing you've learned about templates?

Please try to provide examples -- it would be easier to understand, as opposed to convoluted and overly dry descriptions

Thanks

Answer 1

From "Exceptional C++ style", Item 7: function overload resolution happens before templates specialization. Do not mix overloaded function and specializations of template functions, or you are in for a nasty surprise at which function actually gets called.

template<class T> void f(T t) { ... }   // (a)
template<class T> void f(T *t) { ... }  // (b)
template<> void f<int*>(int *t) { ... } // (c)
...
int *pi; f(pi); // (b) is called, not (c)!

On top of Item 7:

Worse yet, if you omit the type in template specialization, a different function template might get specialized depending on the order of definition and as a result a specialized function may or may not be called.

Case 1:

template<class T> void f(T t) { ... }  // (a)
template<class T> void f(T *t) { ... } // (b)
template<> void f(int *t) { ... }      // (c) - specializes (b)
...
int *pi; f(pi); // (c) is called

Case 2:

template<class T> void f(T t) { ... }  // (a)
template<> void f(int *t) { ... }      // (c) - specializes (a)
template<class T> void f(T *t) { ... } // (b)
...
int *pi; f(pi); // (b) is called

Answer 2

This may not be popular, but I think it needs to be said.

Templates are complicated.

They are awesomely powerful, but use them wisely. Don't go too crazy, don't have too many template arguments... Don't have too many specializations... Remember, other programmers have to read this too.

And most of all, stay away from template metaprogramming...

Answer 3

I'd have to say Coplien's Curiously Recurring Template Pattern (CRTP) is the one template trick that I find myself reaching for over & over again. Essentially it allows you to inject statically customized functionality into a derived class by inheriting from a base class that is parameterized on the derived class name. Mind boggling, but amazingly useful (some call it static polymorphism).

Also, I'll second Neil Butterworth's advice to read "C++ Templates" and throw in Alexandrescu's Modern C++ Design.

Answer 4

Template Tip of the Day: Did you know you can specialize chosen functions of template instantiations:

#include <iostream>
#include <vector>

namespace std {
    template<>
    void vector<int>::clear() {
    std::cout << "Clearing..." << std::endl;
    resize(0);
    }
}

int main() {
    std::vector<int> v;
    v.push_back(1);
    v.clear();
}

ouputs: Clearing...

Of course, this is only an example and, as @Desmond Gold noticed, changing behaviour of standard containers may leads to undefined behaviour.

Answer 5

This question is a bit like "I'm going to implement most of my library using functions, what are the common mistakes in using functions?" It's hard to come up with sensible answers to such questions, but here's my advice - read a good book. I recommend "C++ Templates" by Vandevoorde & Josuttis,

Answer 6

One common mistake is that a template constructor or assignment operator will not suppress the compiler generated one:

template <typename T>
class A {
public:
  template <typename S>
  A(A<S> const &);

  template <typename S>
  A & operator=(A<S> const &);

private:
  int * i;
}; 

Although these functions look like the copy constructor and copy assignment operator, the compiler does not see it that way and generates the implicit versions anyway. The result is that any actions performed by these functions (eg. deep copy of a member) will not take place when the object is copied or assigned to from the same type:

void foo (A<int>);

void bar () {
  A<int> a1;
  foo (a1);   // Implicitly generated copy ctor called

  A<long> a2;
  foo (a2);   // Template ctor called.

  A<int> a3;
  a3 = a1;   // Implicitly generated copy assignment operator called

  a3 = a2;   // Template assignment operator called
}

The reason for this behaviour is due to a special rule in overload resolution (13.3.3):

Given these definitions, a viable function F1 is defined to be a better function than another viable function F2 if for all arguments i, ICSi(F1) is not a worse conversion sequence than ICSi(F2), and then

[...]

— F1 is a non-template function and F2 is a function template specialization, or, if not that,

In the examples above, overload resolution sees two functions with the same signature, one of which is a template. The non template function (the implicitly generated copy constructor/copy assignment operator) wins and so is called.

Answer 7

The STL is your friend.

Answer 8

Here are some rules:

1. Don't write any templates unless you're writing a very, very generic library (STL and Boost are two prominent examples).
2. Don't instantiate any non-trivial template too many times. Instantiating huge template classes is especially overkill. You should consider using inheritance and polymorphism (the simple way, I mean, using virtual functions).
3. If you're writing any templates, knowing when to use const, mutable and volatile will save users of the template both compile and execution time.
4. If you're instantiating any templates, use a good compiler.

Answer 9

Read Meyers's Effective STL and C++ books, and Alexandrescu's Modern C++ Design.

Meyers will give you the basics on easy mistakes to make and how to avoid them. Alexandrescu introduces you to a template-based programming model that should have you asking "Is this really a good idea?" the entire book.

Answer 10

I tend to use templates quite a lot to avoid duplication of code, and to increase safety through compile checks.

In general, it helps to think while typing about what the compiler is going to do, and how the code will be generated for each type.

Being very iterative in development and building the template complexity little by little has helped me avoiding sinking in compile error messages. Don't forget to keep a simple (or mock) instantiation of the template somewhere, otherwise you might have some nasty surprises when you instantiate a monster template for the first time.

Finally, when there is no way out, get to read these compile error messages! They might look quite scary at first, but they really are helpful. Maybe at first extracting the first one, copying it in a text editor and making it look pretty will help getting used to them, and it quickly becomes second nature to read through.

Answer 11

It's important to understand separate compilation and the possibility of resulting executable size increases. If you instantiate the template with the same type in several C++ files, you will get the type reproduced multiple times, at least on some compilers.

Answer 12

I've used c++ and templates a lot, including more advanced template metaprogramming and my feeling is that their usefulness is overrated. They were originally added to the c++ language, well after the creation of c++, to tack on a generic programming capability. This simply allows one to focus on the logic of the code without regard for types, potentially making code clearer and reusable.

My programming philosophy is to understand the original purpose and design of the language and it's features in order to really appreciate the language. I feel template metaprogramming is bastardization of templates and should be avoided. Templates are however useful for defining higher level generic types such as the case of Tuples.