Question

I have heard from many people that usage of templates make the code slow. Is it really true. I’m currently building a library. There are places where if templates are not created, it would result in code management problem. As of now I can think two solutions to this problem:

• use #defines

• Use templates and define all possible types in the header file/library itself but do not allow end user to make template instances.

e.g. typedef Graph<int> GraphI32; etc.

Is there anyway, to restrict user from creating various template instances on their own.

Help on above queries would be highly regarded.

Answer 1

The short answer is no. For the longer answer please read on.

As others have already noted, templates don’t have a direct run-time penalty — i.e. all their tricks happen at compile time. Indirectly, however, they can slow things down under a few circumstances. In particular, each instantiation of a template (normally) produces code that’s separate and unique from other instantiations. Under a few circumstances, this can lead to slow execution, by simply producing enough object code that it no longer fits in the cache well.

With respect to code size: yes, most compilers can and will fold together the code for identical instantiations — but that’s normally the case only when the instantiations are truly identical. The compiler will not insert code to do even the most trivial conversions to get two minutely different instantiations to match each other. For example, a normal function call can and will convert T * to T const * so calls that use either const or non-const arguments will use the same code (unless you’ve chosen to overload the function on constness, in which case you’ve probably done so specifically to provide different behavior for the two cases). With a template, that won’t happen — instantiations over T * and T const * will result in two entirely separate pieces of code being generated. It’s possible the compiler (or linker) may be able to merge the two after the fact, but not entirely certain (e.g., I’ve certainly used compilers that didn’t).

But in the end, templates have positive effects on speed far more often than negative.