Question

According to this article from Herb Sutter, one should always pick Class Specializing over Function Overload and definitely over Specialized Function Templates.

The reason is that

• Specializations don’t overload. 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.
• we can’t particial specialize function templates.

I must admit that before I read the article I have banged my head against the wall a few times. Why isn’t he picking my specialized function …
After reading the article I’ve never used Specialized Function Templates again.

Example:

template <class T> void foo( T t);

We should write foo like this so we can specialize it with class templates instead of function specializing.

template<class T> 
struct FooImpl;

template <class T> void foo( T t) {
    FooImpl<T>::foo(t);
}

Now we can specialze the template and don’t have to worry about the overload rules and we can even partitial specialize the template like this:

template<class U, class V> 
struct FooImpl< QMap< U, V > >;

Here is the question.

It seems that the StackOverflow members prefer Specialized Function Templates?
Why?
Because the Specialized Function Templates get a lot more upvotes than the Overload Solutions and the Class Specializing.
With the information that i have at the moment i find it perverse because i know that i can get it right, but i know that the one who comes after me will hit the wall.

There are already some links to the GOTWCA article so you must have read the article. This means that upvoters must have some extra information, please stand up and enlighten me.

Answer 1

The problem with explicitly specialising a function template only applies if the function is also overloaded:

template <typename T> void foo (T*);   // #1

template <typename T> void foo (T);    // #2
template <> void foo<int*> (int*);

int main () {
  int * i;
  foo (i);  // Calls #1 not specialization of #2
}

Without the #1 overload, the code will work as expected. However, a function that starts out not being overloaded may have overloads added as the code is maintained into the future.

This is one of those examples where, although I hate to say it, C++ has too many ways to do the same thing. Personally, if you find you need to specialise a function template, then I like the pattern suggested by TimW in his comment against Neil Butterworth’s answer, ie. it’s best to do so by having the current function dispatch it’s call to a specialized class template instead:

template <typename T> class DoFoo {
    static void do (T) { /* default behaviour */ }
};
template <> class DoFoo<int*> {
    static void do (int*) { /* int * behaviour */ }
};

template <typename T> void foo (T t)
{
  DoFoo<T>::do (t);
}

If ‘foo’ is overloaded, then at least it’s clearer to the developer that this function won’t be called, ie. the developer doesn’t need to be a standards guru to know how the specialization rules interact with overload resolution.

Ultimately, however, the code generated by the compiler is going to be the same, this is purely a code comprehension issue on the part of the developer.