Will specialization of function templates in std for program-defined types no longer be allowed in C++20?

by

As it stands now it definitly looks that way. Previously [namespace.std] contained

A program may add a template specialization for any standard library template to namespace std only if the declaration depends on a user-defined type and the specialization meets the standard library requirements for the original template and is not explicitly prohibited.

While the current draft states

Unless explicitly prohibited, a program may add a template specialization for any standard library class template to namespace std provided that (a) the added declaration depends on at least one program-defined type and (b) the specialization meets the standard library requirements for the original template.

emphasis mine

And it looks like the paper Thou Shalt Not Specialize std Function Templates! by Walter E. Brown is responsible for it. In it he details an number of reason why this should be changed such as:

  • Herb Sutter: “specializations don’t participate in overloading. […] 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.”
  • David Abrahams: “it’s wrong to use function template specialization [because] it interacts in bad ways with overloads. […] For example,
    if you specialize the regular std::swap for std::vector<mytype>&,
    your specialization won’t get chosen over the standard’s vector
    specific swap, because specializations aren’t considered during
    overload resolution.”
  • Howard Hinnant: “this issue has been settled for a long time. . . . Disregard Dave’s expert opinion/answer in this area at your own
    peril.”
  • Eric Niebler: “[because of] the decidedly wonky way C++ resolves function calls in templates. . . , [w]e make an unqualified call to
    swap in order to find an overload that might be defined in […]
    associated namespaces[…] , and we do using std::swap so that, on
    the off-chance that there is no such overload, we find the default
    version defined in the std namespace.”
  • High Integrity C++ Coding Standard: “Overload resolution does not take into account explicit specializations of function templates. Only
    after overload resolution has chosen a function template will any
    explicit specializations be considered.”

More Related Contents:

  1. Why function template cannot be partially specialized?
  2. What does the namespace std add? (C++) [closed]
  3. What’s the difference between “STL” and “C++ Standard Library”?
  4. Can you remove elements from a std::list while iterating through it?
  5. printf with std::string?
  6. Sorting std::map using value
  7. Can I take the address of a function defined in standard library?
  8. Compelling examples of custom C++ allocators?
  9. How do I Search/Find and Replace in a standard string?
  10. Overload resolution failure when streaming object via implicit conversion to string
  11. Search for a struct item in a vector by member data
  12. What exactly are C++ modules?
  13. How to use std::async on a member function?
  14. What is the fastest way to change a key of an element inside std::map
  15. std::put_time implementation status in GCC?
  16. What is the difference between using a struct with two fields and a pair?
  17. Most terse and reusable way of wrapping template or overloaded functions in function objects
  18. Why would I ever use push_back instead of emplace_back?
  19. How do I erase elements from STL containers?
  20. C++ Concept that requires a member function with an OutputIterator as parameter
  21. Broken c++ std libraries on macOS High Sierra 10.13
  22. std::thread error (thread not member of std)
  23. Why do two functions have the same address?
  24. Why does unique_ptr take two template parameters when shared_ptr only takes one?
  25. What is the use of “using namespace std”? [duplicate]
  26. Why Can’t I store references in a `std::map` in C++?
  27. what does `using std::swap` inside the body of a class method implementation mean?
  28. Is lambdification of a concept an improvement or bad practice?
  29. Why is operator!= removed in C++20 for many standard library types?
  30. How to use C++20’s likely/unlikely attribute in if-else statement

Leave a Comment