Skip site navigation (1)Skip section navigation (2)

FreeBSD Manual Pages

  
 
  

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_lim-
       its<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)

Want to link to this manual page? Use this URL:
<https://man.freebsd.org/cgi/man.cgi?query=std::is_signed&sektion=3&manpath=FreeBSD+Ports+15.1.quarterly>

home | help