std::numeric_limits::is_signed(3)

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 true for all signed arithmetic
   types T and false for the unsigned types. This constant is meaningful for all
   specializations.

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

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)