std::numeric_limits::traps(3)

NAME
std::numeric_limits::traps - std::numeric_limits::traps

Synopsis
   static const bool traps; (until C++11)
   static constexpr bool traps; (since C++11)
   The value of std::numeric_limits<T>::traps is true for all arithmetic types T that
   have at least one value at the start of the program that, if used as an argument to
   an arithmetic operation, will generate a trap.

Standard specializations
   T value of std::numeric_limits<T>::traps
   /* non-specialized */ false
   bool false
   char usually true
   signed char usually true
   unsigned char usually true
   wchar_t usually true
   char8_t (since C++20) usually true
   char16_t (since C++11) usually true
   char32_t (since C++11) usually true
   short usually true
   unsigned short usually true
   int usually true
   unsigned int usually true
   long usually true
   unsigned long usually true
   long long (since C++11) usually true
   unsigned long long (since C++11) usually true
   float usually false
   double usually false
   long double usually false

Notes
   On most platforms integer division by zero always traps, and
   std::numeric_limits<T>::traps is true for all integer types that support the value
   0. The exception is the type bool: even though division by false traps due to
   integral promotion from bool to int, it is the zero-valued int that traps. Zero is
   not a value of type bool.
   On most platforms, floating-point exceptions may be turned on and off at run time
   (e.g. feenableexcept() on Linux or _controlfp on Windows), in which case the value
   of std::numeric_limits<T>::traps for floating-point types reflects the state of
   floating-point trapping facility at the time of program startup, which is false on
   most modern systems. An exception would be a DEC Alpha program, where it is true if
   compiled without -ieee.

Example
// Run this code
 #include <iostream>
 #include <limits>
 int main()
 {
     std::cout << std::boolalpha
               << "bool: traps = " << std::numeric_limits<bool>::traps << '\n'
               << "char: traps = " << std::numeric_limits<char>::traps << '\n'
               << "char16_t: traps = " << std::numeric_limits<char16_t>::traps << '\n'
               << "long: traps = " << std::numeric_limits<long>::traps << '\n'
               << "float: traps = " << std::numeric_limits<float>::traps << '\n';
 }

Possible output:
 // GCC output:
 bool: traps = true
 char: traps = true
 char16_t: traps = true
 long: traps = true
 float: traps = false
 // Clang output:
 bool: traps = false
 char: traps = true
 char16_t: traps = true
 long: traps = true
 float: traps = false
   Defect reports
   The following behavior-changing defect reports were applied retroactively to
   previously published C++ standards.
     DR Applied to Behavior as published Correct behavior
                      it was unclear what is returned if returns the enable status
   LWG 497 C++98 trapping at the start of the program
                      is enabled or disabled at runtime

See also

Floating-point environment
   tinyness_before identifies floating-point types that detect tinyness before rounding
   [static] (public static member constant)
   has_denorm_loss identifies the floating-point types that detect loss of precision as
   [static] denormalization loss rather than inexact result
                   (public static member constant)