Skip to content

Search topics & cppreference

Search all study topics, concept maps, and 6,587 C++ and C reference pages.

std::is_unsigned

std::is_unsigned is a UnaryTypeTrait.

Type support
  • C++11
  • C++14
  • C++17
2 min readView on cppreference
NotebookLM
Defined in header <type_traits>
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.

Template parameters

T - a type to check

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

value
[static]
true if T is an unsigned integral type, false otherwise
(public static member constant)

Member functions

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

Member types

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

Possible implementation

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

Example

example.cpp
#include <iostream>
#include <type_traits>
 
class A {};
static_assert(std::is_unsigned_v<A> == false);
 
enum B : unsigned {};
static_assert(std::is_unsigned_v<B> == false);
 
enum class C : unsigned {};
static_assert(std::is_unsigned_v<C> == 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<float> == false &&
    std::is_unsigned_v<signed int> == false &&
    std::is_unsigned_v<unsigned int> == true &&
    std::is_unsigned_v<bool> == true
);
 
int main() 
{
    // signedness of char is implementation-defined:
    std::cout << std::boolalpha << std::is_unsigned<char>::value << '\n';
}
Possible output
false

Defect reports

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

DR Applied to Behavior as published Correct behavior
LWG 2197 C++11 value could be true even if T is not an arithmetic type can only be false in this case

See also

(C++11)
checks if a type is a signed arithmetic type
(class template)
[static]
identifies signed types
(public static member constant of std::numeric_limits<T>)
checks if a type is an arithmetic type
(class template)
obtains the corresponding signed type for the given integral type
(class template)
obtains the corresponding signed type for the given integral type
(class template)

Content from this page on cppreference.com, licensed under CC-BY-SA 3.0 and GFDL. Modified: restyled, site navigation removed, code windows added. Offline snapshot of 9 February 2025.