C++ template functions overload resolution

by

The unspecialized function templates are also called the underlying base templates. Base templates can be specialized. The overloading rules to see which ones get called in different situations, are pretty simple, at least at a high level:

  • Nontemplate functions are first-class citizens. A plain old nontemplate function that matches the parameter types as well as any function template will be selected over an otherwise-just-as-good function template.

  • If there are no first-class citizens to choose from that are at least as good, then function base templates as the second-class citizens get consulted next. Which function base template gets selected depends on which matches best and is the “most specialized” (important note: this use of “specialized” oddly enough has nothing to do with template specializations; it’s just an unfortunate colloquialism) according to a set of fairly arcane rules:

    • If it’s clear that there’s one “most specialized” function base template, that one gets used. If that base template happens to be specialized for the types being used, the specialization will get used, otherwise the base template instantiated with the correct types will be used.

    • Else (as in your case) if there’s a tie for the “most specialized” function base template, the call is ambiguous because the compiler can’t decide which is a better match. The programmer will have to do something to qualify the call and say which one is wanted.

    • Else if there’s no function base template that can be made to match, the call is bad and the programmer will have to fix the code.

If you want to customize a function base template and want that customization to participate in overload resolution (or, to always be used in the case of exact match), make it a plain old function, not a specialization. And, if you do provide overloads, avoid also providing specializations.

The above is an extract from this post by the Herb Sutter and in the highlighted bullet you can see the source of your problem

EDIT

If you try (don’t do it) the above code with Visual Studio 2012, you get

fatal error LNK1179: invalid or corrupt file: duplicate COMDAT ‘??$f@_N@@YAX_N@Z’

which, as explained here, is because

You did some “trickery” that is invalid C++, and it passed the compiler, but you now have an invalid *.obj, and it chokes the linker.

and the following line is to blame

f(true);        // #1 prints f(T)

so the ambiguity explained in the answer has no guarandeed resolution

More Related Contents:

  1. How does `is_base_of` work?
  2. String literal matches bool overload instead of std::string
  3. Template partial ordering – why does partial deduction succeed here
  4. SFINAE works differently in cases of type and non-type template parameters
  5. Why is it not possible to overload class templates?
  6. C++ overloaded function as template argument
  7. Most terse and reusable way of wrapping template or overloaded functions in function objects
  8. Why does overload of template and non-template function with the “same signature” call the non-template function?
  9. Why do i have a random result on this template?
  10. Templated check for the existence of a class member function?
  11. How does `void_t` work
  12. using extern template (C++11)
  13. SFINAE working in return type but not as template parameter
  14. C++ syntax for explicit specialization of a template function in a template class?
  15. Template deduction for function based on its return type?
  16. Template static variable
  17. constant references with typedef and templates in c++
  18. Is it possible to “store” a template parameter pack without expanding it?
  19. C++11: Compile Time Calculation of Array
  20. How to reverse the order of arguments of a variadic template function?
  21. Template specialization and enable_if problems [duplicate]
  22. String literals not allowed as non type template parameters
  23. (Partially) specializing a non-type template parameter of dependent type
  24. How to check for the type of a template parameter?
  25. Do c++ templates make programs slow?
  26. Why is the STL so heavily based on templates instead of inheritance?
  27. How to make a variadic is_same?
  28. Understanding (simple?) C++ Partial Template Specialization
  29. Does reinterpret_cast lead to undefined behavior?
  30. C++ template function compiles in header but not implementation

Leave a Comment