What can and can’t I specialize in the std namespace?

by

Quoting loosely from the standard:

  • numeric_limits shall not be specialized for non-arithmetic standard types (e.g. complex<T>)

  • “[S]pecializations of shared_ptr shall be CopyConstructible, CopyAssignable, and LessThanComparable [and] convertible to bool.”

  • “Specializations of weak_ptr shall be CopyConstructible and CopyAssignable.”

  • “[T]emplate specializations [of std::hash] shall meet the requirements of class template hash.”

  • Anything in <type_traits>: “The behavior of a program that adds specializations for any of the class templates defined in this subclause is undefined unless otherwise specified.” (only some specializations of common_type are explicitly allowed)

  • Locales have certain required specializations.

  • All specializations of istreambuf_iterator shall have a trivial copy constructor, a constexpr default constructor, and a trivial destructor.

  • “The effect of instantiating the class template complex for any type other than float, double, or long double is unspecified.” I take it that means that defining such other specializations is pointless.

  • “Specializations and instantiations of the atomic template shall have a deleted copy constructor, a deleted copy assignment operator, and a constexpr value constructor.”

  • “The class templates unary_function and binary_function are deprecated. A program shall not declare specializations of these templates.”

And of course the overarching clause 17.6.4.2.1, sentence 1 (thanks @sehe and @curiousguy):

The behavior of a C++ program is undefined if it adds declarations or definitions to namespace std or to a
namespace within namespace std unless otherwise specified. 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.

And sentence 2:

The behavior of a C++ program is undefined if it declares

  • an explicit specialization of any member function of a standard library class template, or

  • an explicit specialization of any member function template of a standard library class or class template, or

  • an explicit or partial specialization of any member class template of a standard library class or class template.

A program may explicitly instantiate a template defined in the standard library only if the declaration
depends on the name of a user-defined type and the instantiation meets the standard library requirements
for the original template.

More Related Contents:

  1. What does the namespace std add? (C++) [closed]
  2. Converting std::__cxx11::string to std::string
  3. Sorting zipped (locked) containers in C++ using boost or the STL
  4. How do I combine hash values in C++0x?
  5. Flattening iterator
  6. Why is the destructor of a future returned from `std::async` blocking?
  7. Should I use std::function or a function pointer in C++?
  8. How std::bind works with member functions
  9. How to convert std::chrono::time_point to calendar datetime string with fractional seconds?
  10. When is it necessary to use the flag -stdlib=libstdc++?
  11. How to use std::async on a member function?
  12. std::bind overload resolution
  13. std::put_time implementation status in GCC?
  14. C++ When is it OK to extend the `std` namespace?
  15. C++ Add months to chrono::system_clock::time_point
  16. How can I use Standard Library (STL) classes in my dll interface or ABI?
  17. Why would I ever use push_back instead of emplace_back?
  18. Is there a range class in C++11 for use with range based for loops?
  19. Passing rvalues through std::bind
  20. How do I erase elements from STL containers?
  21. cc1plus: error: unrecognized command line option “-std=c++11” with g++
  22. std::thread error (thread not member of std)
  23. std::remove_const with const references
  24. std::forward_list and std::forward_list::push_back
  25. stoi and std::to_string on mingw 4.7.1 [duplicate]
  26. Why does unique_ptr take two template parameters when shared_ptr only takes one?
  27. C++ std::tuple order of destruction
  28. I want to kill a std::thread using its thread object? [duplicate]
  29. map with incomplete value type
  30. Why can’t I capture this by-reference (‘&this’) in lambda?

Leave a Comment