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.

More Related Contents:

  1. Why is it OK to return a ‘vector’ from a function?
  2. Why is it not possible to overload class templates?
  3. How does overloading of const and non-const functions work?
  4. STL algorithms: Why no additional interface for containers (additional to iterator pairs)?
  5. What’s the difference between “STL” and “C++ Standard Library”?
  6. Is std::vector so much slower than plain arrays?
  7. How to convert wstring into string?
  8. std::endl is of unknown type when overloading operator
  9. Writing your own STL Container
  10. Why does the C++ STL not provide any “tree” containers?
  11. Why doesn’t std::queue::pop return value.?
  12. Overload resolution between object, rvalue reference, const reference
  13. what happens when you modify an element of an std::set?
  14. What’s faster, iterating an STL vector with vector::iterator or with at()?
  15. How to remove all the occurrences of a char in c++ string
  16. Copy map values to vector in STL [duplicate]
  17. std::map, pointer to map key value, is this possible?
  18. Why does the most negative int value cause an error about ambiguous function overloads?
  19. Efficiency of the STL priority_queue
  20. Capturing a time in milliseconds
  21. Most terse and reusable way of wrapping template or overloaded functions in function objects
  22. Performance of qsort vs std::sort?
  23. How does C++ STL unordered_map resolve collisions?
  24. How do I erase elements from STL containers?
  25. STL analogue in Fortran
  26. Why the libc++ std::vector internally keeps three pointers instead of one pointer and two sizes?
  27. Visual c++ “for each” portability
  28. Is stl vector concurrent read thread-safe?
  29. Why can’t I replace std::map with std::unordered_map
  30. what does `using std::swap` inside the body of a class method implementation mean?

Leave a Comment