Why Not Specialize Function Templates?
This article appeared in C/C++ Users Journal, 19(7), July 2001.
While the title of this article is a question, it could also be made into a statement: this article is about when and why not to specialize templates.
The Important Difference: Overloading vs. Specialization
It's important to make sure we have the terms down pat, so here's a quick review.
In C++, there are class templates and function templates. These two kinds of templates don't work in exactly the same ways, and the most obvious difference is in overloading: Plain old C++ classes don't overload, so class templates don't overload either. On the other hand, plain old C++ functions having the same name do overload, and so function templates are allowed to overload too. This is pretty natural. What we have so far is summarized in Example 1:
// Example 1: Class vs. function template, and overloading
// A class template
// A function template with two overloads
These unspecialized templates are also called the underlying base templates.
Further, base templates can be specialized. This is where class templates and function templates diverge further, in ways that will become important later in this article. A class template can be partially specialized and/or fully specialized. A function template can only be fully specialized, but because function templates can overload we can get nearly the same effect via overloading that we could have got via partial specialization. The following code illustrates these differences:
// Example 1, continued: Specializing templates
// A partial specialization of (a) for pointer types
// A full specialization of (a) for int
// A separate base template that overloads (b) and (c)
// A full specialization of (b) for int
// A plain old function that happens to overload with
Finally, let's focus on function templates only and consider the overloading rules to see which ones get called in different situations. The rules are pretty simple, at least at a high level, and can be expressed as a classic two-class system:
Putting these rules together, here's a sample of what we get:
// Example 1, continued: Overload resolution
f( b ); // calls (b) with T = bool
So far I've deliberately chosen simpler cases, because here's where we step off into the deep end of the pool.
Why Not Specialize: The Dimov/Abrahams Example
Consider the following code:
// Example 2: Explicit specialization
template<class T> // (b) a second base template, overloads (a)
template<> // (c) explicit specialization of (b)
The result for the last line in Example 2 is just what you'd expect. The question of the day, however, is why you expected it. If you expected it for the wrong reason, you will be very surprised by what comes next. After all, "So what," someone might say, "I wrote a specialization for a pointer to int, so obviously that's what should be called" - and that's exactly the wrong reason.
Consider now the following code, put in this form by Peter Dimov and Dave Abrahams:
// Example 3: The Dimov/Abrahams Example
template<> // (c) explicit specialization, this time of (a)
template<class T> // (b) a second base template, overloads (a)
If this surprises you, you're not alone; it has surprised a lot of experts in its time. The key to understanding this is simple, and here it is: Specializations don't overload.
Only the base templates overload (along with nontemplate functions, of course). Consider again the salient part from the summary I gave above of the overload resolution rules, this time with specific words highlighted:
Overload resolution only selects a base template (or a nontemplate function, if one is available). Only after it's been decided which base template is going to be selected, and that choice is locked in, will the compiler look around to see if there happens to be a suitable specialization of that template available, and if so that specialization will get used.
If you're like me, the first time you see this you'll ask the question: "Hmm. But it seems to me that I went and specifically wrote a specialization for the case when the parameter is an int*, and it is an int* which is an exact match, so shouldn't my specialization always get used?" That, alas, is a mistake: If you want to be sure it will always be used in the case of exact match, that's what a plain old function is for -- so just make it a function instead of a specialization.
The rationale for why specializations don't participate in overloading is simple, once explained, because the surprise factor is exactly the reverse: The standards committee felt it would be surprising that, just because you happened to write a specialization for a particular template, that it would in any way change which template gets used. Under that rationale, and since we already have a way of making sure our version gets used if that's what we want (we just make it a function, not a specialization), we can understand more clearly why specializations don't affect which template gets selected.
But what if you're the one who's writing, not just using, a function template? Can you do better and avoid this (and other) problem(s) up front, for yourself and for your users? Indeed you can:
// Example 4: Illustrating Moral #2
It's okay to overload function templates. Overload resolution considers all base templates equally and so it works as you would naturally expect from your experience with normal C++ function overloading: Whatever templates are visible are considered for overload resolution, and the compiler simply picks the best match.
It's a lot less intuitive to specialize function templates. For one thing, you can't partially specialize them -- pretty much just because the language says you can't. For another thing, function template specializations don't overload. This means that any specializations you write will not affect which template gets used, which runs counter to what most people would intuitively expect. After all, if you had written a nontemplate function with the identical signature instead of a function template specialization, the nontemplate function would always be selected because it's always considered to be a better match than a template.
If you're writing a function template, prefer to write it as a single function template that should never be specialized or overloaded, and implement the function template entirely in terms of a class template. This is the proverbial level of indirection that steers you well clear of the limitations and dark corners of function templates. This way, programmers using your template will be able to partially specialize and explicitly specialize the class template to their heart's content without affecting the expected operation of the function template. This avoids both the limitation that function templates can't be partially specialized, and the sometimes surprising effect that function template specializations don't overload. Problem solved.
If you're using someone else's plain old function template (one that's not implemented in terms of a class template as suggested above), and you want to write your own special-case version that should participate in overloading, don't make it a specialization; just make it an overloaded function with the same signature.
Thanks to Peter Dimov and Dave Abrahams for prompting me to write about this topic and offering the key example, and to John Spicer for helping me get my head around the rationale for why things are the way they are.
2. There is some discussion going on within the committee about potentially allowing function template partial specialization in the next version of the C++ standard, whose work is just getting under way.