< cpp‎ | types
Metaprogramming library
Type traits
Type categories
Type properties
(C++11)(until C++20*)
(C++11)(deprecated in C++20)
Type trait constants
Supported operations
Relationships and property queries
Type modifications
Type transformations
(C++11)(deprecated in C++23)
(C++11)(deprecated in C++23)

(C++11)(until C++20*)(C++17)
Compile-time rational arithmetic
Compile-time integer sequences
Defined in header <type_traits>
template< class T >
struct is_signed;
(since C++11)

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.


[edit] Template parameters

T - a type to check

[edit] Helper variable template

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

Inherited from std::integral_constant

Member constants

true if T is a signed arithmetic type, false otherwise
(public static member constant)

Member functions

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

Member types

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

[edit] 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 {};

[edit] Example

#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);
    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:


[edit] See also

checks if a type is an unsigned arithmetic type
(class template) [edit]
identifies signed types
(public static member constant of std::numeric_limits<T>) [edit]
checks if a type is an arithmetic type
(class template) [edit]
makes the given integral type signed
(class template) [edit]
makes the given integral type unsigned
(class template) [edit]