Template Specialization VS Function Overloading

by

Short story: overload when you can, specialise when you need to.

Long story: C++ treats specialisation and overloads very differently. This is best explained with an example.

template <typename T> void foo(T);
template <typename T> void foo(T*); // overload of foo(T)
template <>           void foo<int>(int*); // specialisation of foo(T*)

foo(new int); // calls foo<int>(int*);

Now let’s swap the last two.

template <typename T> void foo(T);
template <>           void foo<int*>(int*); // specialisation of foo(T)
template <typename T> void foo(T*); // overload of foo(T)

foo(new int); // calls foo(T*) !!!

The compiler does overload resolution before it even looks at specialisations. So, in both cases, overload resolution chooses foo(T*). However, only in the first case does it find foo<int*>(int*) because in the second case the int* specialisation is a specialisation of foo(T), not foo(T*).

You mentioned std::swap. This makes things even more complicated.

The standard says that you can add specialisations to the std namespace. Great, so you have some Foo type and it has a performant swap then you just specialise swap(Foo&, Foo&) in the std namespace. No problems.

But what if Foo is a template class? C++ doesn’t have partial specialisation of functions, so you can’t specialise swap. Your only choice is overloading, but the standard says that you aren’t allowed to add overloads into the std namespace!

You have two options at this point:

  1. Create a swap(Foo<T>&, Foo<T>&) function in your own namespace, and hope that it gets found via ADL. I say “hope” because if the standard library calls swap like std::swap(a, b); then ADL simply won’t work.

  2. Ignore the part of the standard that says not to add overloads and do it anyway. Honestly, even though it’s technically not allowed, in all realistic scenarios it’s going to work.

One thing to remember though is that there’s no guarantee that the standard library uses swap at all. Most algorithms use std::iter_swap and in some implementations that I’ve looked at, it doesn’t always forward to std::swap.

Leave a Comment

tech