C++ - What is the purpose of function template specialization? When to use it?

Learn开发者_开发知识库ing C++, came upon function templates. The chapter mentioned template specialization.

1. template <> void foo<int>(int);

2. void foo( int );

Why specialize when you can use the second? I thought templates were suppose to generalize. What's the point of specializing a function for a specific data type when you can just use a regular function?

Obviously, template specialization exists for a reason. When should it be used? I read Sutter's "Why not Specialize..." article but I need more of a layman's version since I'm just learning this stuff.

---

The main difference is that in the first case you are providing the compiler with an implementation for the particular type, while in the second you are providing an unrelated non-templated function.

If you always let the compiler infer the types, non-templated functions will be preferred by the compiler over a template, and the compiler will call the free function instead of the template, so providing a non-templated function that matches the arguments will have the same effect of specializations in most cases.

On the other hand, if at any place you provide the template argument (instead of letting the compiler infer), then it will just call the generic template and probably produce unexpected results:

template <typename T> void f(T) { 
   std::cout << "generic" << std::endl; 
}
void f(int) { 
   std::cout << "f(int)" << std::endl; 
}
int main() {
   int x = 0;
   double d = 0.0;
   f(d); // generic
   f(x); // f(int)
   f<int>(x); // generic !! maybe not what you want
   f<int>(d); // generic (same as above)
}

If you had provided an specialization for int of the template, the last two calls would call that specialization and not the generic template.

---

I personally can see no benefit from specializing a function template. Overloading it by either a different function template or a non-template function is arguably superior because its handling is more intuitive and it's overall more powerful (effectively by overloading the template, you have a partial specialization of the template, even though technically it's called partial ordering).

Herb Sutter has written an article Why not specialize function templates? where he discourages specializing function templates in favour of either overloading them or writing them so that they just forward to a class template's static function and specializing the class template instead.

---

You can use specialization when you know for a specific class the generic method could be efficient.

template<typename T>
void MySwap(T& lhs, T& rhs)
{
    T tmp(lhs);
    lhs  = rhs;
    rhs  = tmp;
}

Now for vectors my swap will work, but is not very effecient. But I also know that std::vector implements its own swap() method.

template<>
void MySwap(std::vector<int>& lhs,std::vector<int>& rhs)
{
    lhs.swap(rhs);
}

Please don;t compare to std::swap which is a lot more complex and better written. This is just an example to show that a generic version of MySwap() will work but is may not always be efficient. As a result I have shown how it can be made more efficient with a very specific template specialization.

We can also of course use overloading to achieve the same effect.

void MySwap(std::vector<int>& lhs,std::vector<int>& rhs)
{
    lhs.swap(rhs);
}

So the question if why use template specialization (if one can use overloading). Why indeed. A non template function will always be chosen over a template function. So template specialization rules are not even invoked (which makes life a lot simpler as those rules are bizarre if you are not a lawyer as well as a computer programmer). So let me thing a second. No can't think of a good reason.

---

I find it very important. You can use this as you would use a virtual method. There would be no point in virtual methods unless some of them were specialized. I have used it a lot to differentiate between simple types (int,short,float) and objects, object pointers and object references. An example would be serialize/unserialize methods that would handle objects by calling the objects serialize/unserialize method, while simple types should be written directly to a stream.

---

One case for template specialization which is not possible with overloading is for template meta-programming. The following is real code from a library that provides some of it services at compile time.

namespace internal{namespace os{
    template <class Os> std::ostream& get();

    struct stdout{};
    struct stderr{};

    template <> inline std::ostream& get<stdout>() { return std::cout; }
    template <> inline std::ostream& get<stderr>() { return std::cerr; }
}}

// define a specialization for os::get()
#define DEFINE_FILE(ofs_name,filename)\
    namespace internal{namespace os{                        \
        struct ofs_name{                                    \
            std::ofstream ofs;                              \
            ofs_name(){ ofs.open(filename);}                        \
            ~ofs_name(){ ofs.close(); delete this; }                    \
        };                                          \
        template <> inline std::ostream& get<ofs_name>(){ return (new ofs_name())->ofs; }   \
    }}                                              \
    using internal::os::ofs_name;   

---

Multiple overloads on the same name do similar things. Specializations do the exact same thing, but on different types. Overloads have the same name, but may be defined in different scopes. A template is declared in only one scope, and the location of a specialization declaration is insignificant (although it must be at the scope of the enclosing namespace).

For example, if you extend std::swap to support your type, you must do so by specialization, because the function is named std::swap, not simply swap, and the functions in <algorithm> would be quite right to specifically call it as ::std::swap( a, b );. Likewise for any name that might be aliased across namespaces: calling a function may get "harder" once you qualify the name.

The scoping issue is confused further by argument-dependent lookup. Often an overload may be found because it is defined in proximity to the type of one of its arguments. (For example, as a static member function.) This is completely different from how the template specialization would be found, which is by simply looking up the template name, and then looking up the explicit specialization once the template has been chosen as the target of the call.

The rules of ADL are the most confusing part of the standard, so I prefer explicit specialization on the priciple of avoiding reliance on it.