std::is_unsigned - cppreference.com (original) (raw)

| | | | | ----------------------------------------- | | ------------- | | template< class T > struct is_unsigned; | | (since C++11) |

std::is_unsigned is a UnaryTypeTrait.

Checks whether T is an unsigned arithmetic type.

• If std::is_arithmetic<T>::value is true, provides the member constant value equal to T(0) < T(-1).
• Otherwise, provides the member constant value equal to false.

If the program adds specializations for std::is_unsigned or std::is_unsigned_v, the behavior is undefined.

Contents

• 1 Template parameters
• 2 Helper variable template
• 3 Inherited from std::integral_constant
  • 3.1 Member constants
  • 3.2 Member functions
  • 3.3 Member types
  • 3.4 Possible implementation
  • 3.5 Example
  • 3.6 Defect reports
  • 3.7 See also

[edit] Template parameters

[edit] Helper variable template

| template< class T > constexpr bool is_unsigned_v = is_unsigned<T>::value; | | (since C++17) | | ------------------------------------------------------------------------------- | | ------------- |

Inherited from std::integral_constant

Member constants

| | true if T is an unsigned integral type, false otherwise (public static member constant) | | ------------------------------------------------------------------------------------------ |

Member functions

| | converts the object to bool, returns value (public member function) | | ---------------------------------------------------------------------- | | | returns value (public member function) |

Member types

[edit] Possible implementation

namespace detail { template<typename T,bool = std::is_arithmetic::value> struct is_unsigned : std::integral_constant<bool, T(0) < T(-1)> {};   template struct is_unsigned<T,false> : std::false_type {}; } // namespace detail   template struct is_unsigned : detail::is_unsigned::type {};

[edit] Example

#include #include   class A {}; static_assert(std::is_unsigned_v == false);   enum B : unsigned {}; static_assert(std::is_unsigned_v == false);   enum class C : unsigned {}; static_assert(std::is_unsigned_v == false);   struct S { unsigned p : 1; int q : 1; }; static_assert ( std::is_unsigned_v<decltype(S::p)> not_eq std::is_unsigned_v<decltype(S::q)> );   static_assert ( std::is_unsigned_v == false && std::is_unsigned_v == false && std::is_unsigned_v == true && std::is_unsigned_v == true );   int main() { // signedness of char is implementation-defined: std::cout << std::boolalpha << std::is_unsigned::value << '\n'; }

Possible output:

[edit] Defect reports

The following behavior-changing defect reports were applied retroactively to previously published C++ standards.

[edit] See also

| | checks if a type is a signed arithmetic type (class template) [edit] | | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | | identifies signed types (public static member constant of std::numeric_limits) [edit] | | | checks if a type is an arithmetic type (class template) [edit] | | | obtains the corresponding signed type for the given integral type (class template) [edit] | | | obtains the corresponding signed type for the given integral type (class template) [edit] |