std::numeri...::is_signed(3)

🎀 std::numeri...::is_signed(3) 🎀

okay so welcome to the <pink>std::numeri...::is_signed(3)</pink> page from the <purple>C++ Standard Libary</purple>, bestie ✨ this one is all about the is_signed` trait and it is lowkey iconic. no cap, it’s giving “is this type signed or not?” energy 💅

💖 NAME 💖

std::numeric_limits::is_signed — std::numeric_limits::is_signed

🦋 Synopsis 🦋

static const bool is_signed;      (until C++11)
static constexpr bool is_signed;  (since C++11)

The value of std::numeric_limits<T>::is_signed is <green>true</green> for all signed arithmetic types T and <red>false</red> for the unsigned types. This constant is meaningful for all specializations. periodt 💫

🌈 Standard specializations 🌈

okay bestie, here’s the whole lineup of T and the value of std::numeric_limits<T>::is_signed — every single one, no skipping 🫶

• /* non-specialized */ — false
• bool — false
• char — implementation-defined
• signed char — true
• unsigned char — false
• wchar_t — implementation-defined
• char8_t (since C++20) — false
• char16_t (since C++11) — false
• char32_t (since C++11) — false
• short — true
• unsigned short — false
• int — true
• unsigned int — false
• long — true
• unsigned long — false
• long long (since C++11) — true
• unsigned long long (since C++11) — false
• float — true
• double — true
• long double — true

<yellow>implementation-defined</yellow> for char and wchar_t means the implementation gets to decide — that’s the vibe here 💅

🔥 Example 🔥

// Run this code

#include <iostream>
#include <iomanip>
#include <limits>

template<typename T>
struct test
{
    test(const char* name, int w = 15)
    {
        std::cout
            << std::left << std::setw(w)
            << (std::numeric_limits<T>::is_specialized ? name : "non-specialized")
            << " : "
            << (std::numeric_limits<T>::is_signed ? "" : "un") << "signed\n";
    }
};

int main()
{
    test<bool>{"bool"};
    test<char>{"char"};
    test<wchar_t>{"wchar_t"};
    test<char16_t>{"char16_t"};
    test<char32_t>{"char32_t"};
    test<float>{"float"};
    struct delusion{};
    test<delusion>{"delusion"};
    test<decltype(42)>{"decltype(42)"};
}

💬 Possible output 💬

bool            : unsigned
char            : signed
wchar_t         : signed
char16_t        : unsigned
char32_t        : unsigned
float           : signed
non-specialized : unsigned
decltype(42)    : signed

👑 See also 👑

• is_signed — checks if a type is a signed arithmetic type (C++11) (class template)
• is_integer — identifies integer types [static] (public static member constant)
• is_exact — identifies exact types [static] (public static member constant)
• is_bounded — identifies types that represent a finite set of values [static] (public static member constant)

mwah 💋 this page came from <pink>http://cppreference.com</pink>, dated <lavender>2024.06.10</lavender>, and it’s the <rainbow>std::numeri...::is_signed(3)</rainbow> manual page. bye bestie, go check those signed vibes 🫶🎀