std::numeric_limits::traps(3)

💅 std::numeric_limits::traps 💅

okay so this is the std::numeric_limits::traps(3) page from the C++ Standard Libary, and we're gonna make it make sense together 🫶 no cap.

---

💖 NAME 💖

std::numeric_limits::traps — std::numeric_limits::traps 💅 (yes bestie, it's giving name-so-nice-you-say-it-twice).

---

✨ Synopsis ✨

here's the shape of it, and the version glow-up is right there:

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. literally that's the whole vibe check 🔥

---

🌸 Standard specializations 🌸

here's the whole lineup for T and the value of std::numeric_limits<T>::traps — no skips, no shortcuts 💅:

• /* 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 🧠

okay so the tea ☕: 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 — periodt 💅.

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. iykyk 🌈

---

💻 Example 💻

run this code, bestie — it's literally the glow-up of traps:

        // 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:

• LWG 497 — applied to C++98
  • behavior as published: it was unclear what is returned if the trapping is enabled or disabled at runtime
  • correct behavior: returns the enable status at the start of the program

---

👀 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 denormalization loss rather than inexact result; [static] (public static member constant)

---

xoxo, your Unix bestie 💖 — source/version: http://cppreference.com, date 2024.06.10, manual std::numeric_limits::traps(3) ✨🎀