std::numeri...mits::lowest(3)

💅 std::numeri...mits::lowest(3) 💅

okay bestie, welcome to the C++ Standard Libary manual page for std::numeric_limits::lowest, section (3) energy. This one is all about the lowest finite value a numeric type can hold, and it is so useful. No cap. ✨

🌸 NAME 🌸

std::numeric_limits::lowest — std::numeric_limits::lowest (yes, she said what she said 💅)

✨ Synopsis ✨

static constexpr T lowest() noexcept;  (since C++11)

So this returns the lowest finite value representable by the numeric type T — that is, a finite value x such that there is no other finite value y where y < x. For floating-point types, this is different from std::numeric_limits<T>::min(). It’s only meaningful for bounded types. 🫶

🎀 Return value 🎀

Left side is T; right side is std::numeric_limits<T>::lowest():

• /* non-specialized */ — T()
• bool — false
• char — CHAR_MIN
• signed char — SCHAR_MIN
• unsigned char — 0
• wchar_t — WCHAR_MIN
• char8_t (since C++20) — 0
• char16_t — 0
• char32_t — 0
• short — SHRT_MIN
• unsigned short — 0
• int — INT_MIN
• unsigned int — 0
• long — LONG_MIN
• unsigned long — 0
• long long — LLONG_MIN
• unsigned long long — 0
• float — -FLT_MAX
• double — -DBL_MAX
• long double — -LDBL_MAX

🦋 Notes 🦋

For every standard C++ floating-point type T, std::numeric_limits<T>::lowest() == -std::numeric_limits<T>::max() — like, that equality is giving for standard floats. But this does not necessarily have to be the case for any third-party specialization. So don’t assume, bestie. 🙈

🔥 Example 🔥

Demonstrates min(), max(), and lowest() for floating-point types. The page literally says // Run this code, so run it, bestie:

#include <iostream>
#include <limits>
#include <string_view>

template<typename T>
void print_twice(std::string_view type, T value)
{
    std::cout << '\t' << type << ": "
              << std::defaultfloat << value << " or "
              << std::hexfloat << value << '\n';
}

int main()
{
    // min()
    std::cout << "std::numeric_limits<T>::min():\n";
    print_twice("float", std::numeric_limits<float>::min());
    print_twice("double", std::numeric_limits<double>::min());
    print_twice("long double", std::numeric_limits<long double>::min());

    // lowest()
    std::cout << "std::numeric_limits<T>::lowest():\n";
    print_twice("float", std::numeric_limits<float>::lowest());
    print_twice("double", std::numeric_limits<double>::lowest());
    print_twice("long double", std::numeric_limits<long double>::lowest());

    // max()
    std::cout << "std::numeric_limits<T>::max():\n";
    print_twice("float", std::numeric_limits<float>::max());
    print_twice("double", std::numeric_limits<double>::max());
    print_twice("long double", std::numeric_limits<long double>::max());
}

💻 Output 💻

std::numeric_limits<T>::min():
        float: 1.17549e-38 or 0x1p-126
        double: 2.22507e-308 or 0x1p-1022
        long double: 3.3621e-4932 or 0x8p-16385
std::numeric_limits<T>::lowest():
        float: -3.40282e+38 or -0x1.fffffep+127
        double: -1.79769e+308 or -0x1.fffffffffffffp+1023
        long double: -1.18973e+4932 or -0xf.fffffffffffffffp+16380
std::numeric_limits<T>::max():
        float: 3.40282e+38 or 0x1.fffffep+127
        double: 1.79769e+308 or 0x1.fffffffffffffp+1023
        long double: 1.18973e+4932 or 0xf.fffffffffffffffp+16380

👑 See also 👑

• min [static] — returns the smallest finite value of the given type (public static member function)
• denorm_min [static] — returns the smallest positive subnormal value of the given floating-point type (public static member function)
• max [static] — returns the largest finite value of the given type (public static member function)

okay that’s the tea, bestie: this iconic page comes from source http://cppreference.com, version/date 2024.06.10, and the manual page is std::numeri...mits::lowest(3). periodt 💅💖