home | help 
std::is_signed(3)	       C++ Standard Libary	       std::is_signed(3)

NAME
     std::is_signed - std::is_signed

Synopsis
	Defined in header <type_traits>
	template< class T >		 (since C++11)
	struct is_signed;

	std::is_signed is a UnaryTypeTrait.

	If  T is an arithmetic type, provides the member constant value equal to
     true if
	T(-1) < T(0): this results in true for the floating-point types and  the
     signed
	integer  types, and in false for the unsigned integer types and the type
     bool.

	For any other type, value is false.

	If   the   program   adds   specializations   for   std::is_signed    or
     std::is_signed_v, the
	behavior is undefined.

Template parameters
	T - a type to check

	Helper variable template

	template< class T >					  (since C++17)
	inline constexpr bool is_signed_v = is_signed<T>::value;

     Inherited from std::integral_constant

Member constants
	value	 true if T is a signed arithmetic type, false otherwise
	[static] (public static member constant)

Member functions
	operator bool converts the object to bool, returns value
		      (public member function)
	operator()    returns value
	(C++14)       (public member function)

Member types
	Type	   Definition
	value_type bool
	type	   std::integral_constant<bool, value>

Possible implementation
	namespace detail
	{
	    template<typename T, bool = std::is_arithmetic<T>::value>
	    struct is_signed : std::integral_constant<bool, T(-1) < T(0)> {};

	    template<typename T>
	    struct is_signed<T, false> : std::false_type {};
	}

	template<typename T>
	struct is_signed : detail::is_signed<T>::type {};

Example
     // Run this code

      #include <iostream>
      #include <type_traits>

      class A {};
      static_assert(std::is_signed_v<A> == false);

      class B { int i; };
      static_assert(std::is_signed_v<B> == false);

      enum C : int {};
      static_assert(std::is_signed_v<C> == false);

      enum class D : int {};
      static_assert(std::is_signed_v<D> == false);

      static_assert(
	  std::is_signed<signed int>::value == true and // C++11
	  std::is_signed<signed int>() == true and	// C++11
	  std::is_signed<signed int>{} == true and	// C++11
	  std::is_signed_v<signed int> == true and	// C++17
	  std::is_signed_v<unsigned int> == false and
	  std::is_signed_v<float> == true and
	  std::is_signed_v<bool> == false and
	  std::is_signed_v<signed char> == true and
	  std::is_signed_v<unsigned char> == false
      );

      int main()
      {
	  // signedness of char is implementation-defined:
	  std::cout << std::boolalpha << std::is_signed_v<char> << '\n';
      }

Possible output:
      true

See also
	is_unsigned   checks if a type is an unsigned arithmetic type
	(C++11)       (class template)
	is_signed     identifies signed types
	[static]      (public static member constant of std::numeric_limits<T>)
	is_arithmetic checks if a type is an arithmetic type
	(C++11)       (class template)
	make_signed   makes the given integral type signed
	(C++11)       (class template)
	make_unsigned makes the given integral type unsigned
	(C++11)       (class template)

http://cppreference.com 	   2024.06.10		       std::is_signed(3)
home | help