Extending the namespace std

• 1 Adding declarations to std
• 2 Adding template specializations
  • 2.1 Class templates
  • 2.2 Function templates and member functions of templates
  • 2.3 Variable templates
• 3 Explicit instantiation of templates
• 4 Other restrictions
  • 4.1 Addressing restriction
  • 4.2 Designated addressable functions
• 5 Defect reports

• None of the templates defined in <type_traits> may be specialized for a program-defined type, except for std::common_type and std::basic_common_reference (since C++20). This includes the type traits and the class template std::integral_constant .

• Specializations of std::hash for program-defined types must satisfy Hash requirements.

• Specializations of std::atomic must have a deleted copy constructor, a deleted copy assignment operator, and a constexpr value constructor.

• Specializations of std::shared_ptr and std::weak_ptr must be CopyConstructible and CopyAssignable. In addition, specializations of std::shared_ptr must be LessThanComparable, and convertible to bool.

• Specializations of std::istreambuf_iterator must have a trivial copy constructor, a constexpr default constructor, and a trivial destructor.

• std::unary_function and std::binary_function may not be specialized.

It is allowed to add template specializations for any standard library function template to the namespace std only if the declaration depends on at least one program-defined type and the specialization satisfies all requirements for the original template, except where such specializations are prohibited.

It is undefined behavior to declare a full specialization of any standard library function template.

It is undefined behavior to declare a full or partial specialization of any standard library variable template, except where explicitly allowed.

[edit] Explicit instantiation of templates

It is allowed to explicitly instantiate a class (since C++20)template defined in the standard library only if the declaration depends on the name of at least one program-defined type and the instantiation meets the standard library requirements for the original template.

[edit] Other restrictions

The namespace std may not be declared as an inline namespace.

#include <cmath>
#include <memory>
 
int main()
{
 // by unary operator&
 auto fptr0 = &static_cast<float(&)(float, float)>(std::betaf );
 
 // by std::addressof
 auto fptr1 = std::addressof (static_cast<float(&)(float, float)>(std::betaf ));
 
 // by function-to-pointer implicit conversion
 auto fptr2 = static_cast<float(&)(float)>(std::riemann_zetaf );
 
 // forming a reference
 auto& fref = static_cast<float(&)(float)>(std::riemann_zetaf );
}

[edit] Defect reports

The following behavior-changing defect reports were applied retroactively to previously published C++ standards.