is it ok to specialize std::numeric_limits for user-defined number-like classes?

by

Short answer:

Go ahead, nothing bad will happen.

Long answer:

The C++ standard extensively protects the ::std namespace in C++11 17.6.4.2.1, but specifically allows your case in paragraphs 1 and 2:

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.

[…] 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.

The older C++03 has a similar definition in 17.4.3.1/1:

It is undefined for a C++ program to add declarations or definitions to namespace std or namespaces
within namespace std unless otherwise specified. A program may add template specializations for any
standard library template to namespace std. Such a specialization (complete or partial) of a standard
library template results in undefined behavior unless the declaration depends on a user-defined name of
external linkage and unless the specialization meets the standard library requirements for the original template.

After getting past this fundamental stepping stone, you already pointed out, C++03 18.2.1/4 forbids specializations of ::std::numeric_limits for certain types:

Non-fundamental standard types, such as complex (26.2.2), shall not have specializations.

The more current C++11 18.3.2.1/4 has a slightly different wording:

Non-arithmetic standard types, such as complex<T> (26.4.2), shall not have specializations.

Both of these formulations however allow specializations for non-standard types, which T is, since you defined it yourself (as @BoPersson already pointed out in the comments).

Caveats

C++11 18.3.2.3/1 hints that you should (but does not require you to) ensure that your specialization has all members.

Also, you may wish to ensure that C++11 18.3.2.3/2 is not violated by your specialization:

The value of each member of a specialization of numeric_limits on a cv-qualified type cv T shall be equal
to the value of the corresponding member of the specialization on the unqualified type T.

Which essentially means, that if you wish to specialize it for T, you should also do so for T const, T volatile and T const volatile.

More Related Contents:

  1. Why don’t the C or C++ standards explicitly define char as signed or unsigned?
  2. What are declarations and declarators and how are their types interpreted by the standard?
  3. Does the size of an int depend on the compiler and/or processor?
  4. Why are Standard iterator ranges [begin, end) instead of [begin, end]?
  5. Return type of ‘?:’ (ternary conditional operator)
  6. How much is too much with C++11 auto keyword?
  7. Difference between void main and int main in C/C++? [duplicate]
  8. Why will std::sort crash if the comparison function is not as operator
  9. Deprecation of the static keyword… no more?
  10. When to use std::size_t?
  11. What’s the difference between size_t and int in C++?
  12. Should I use double or float?
  13. Is `long` guaranteed to be at least 32 bits?
  14. Why do compilers allow string literals not to be const?
  15. Is it legal to redefine a C++ keyword?
  16. OpenMP set_num_threads() is not working
  17. Why the sizeof(bool) is not defined to be one, by the Standard itself?
  18. Is it legal to use the increment operator in a C++ function call?
  19. What is the best way to generate random numbers in C++?
  20. Is a C++ preprocessor identical to a C preprocessor?
  21. How do unsigned integers work
  22. Do I have to use #include beside ?
  23. Are there types bigger than long long int in C++?
  24. Switch passed type from template
  25. C++ 128/256-bit fixed size integer types
  26. Template type deduction in C++ for Class vs Function?
  27. ISO C++ standard draft
  28. Why must a std::ranges::filter_view object be non-const for querying its elements?
  29. is size_t always unsigned?
  30. Is there a way to write a large number in C++ source code with spaces to make it more readable? [duplicate]

Leave a Comment