Skip to content

Search topics & cppreference

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

std::is_signed

std::is_signed 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_signed;
(since C++11)

std::is_signed is a UnaryTypeTrait.

Checks whether T is a signed arithmetic type.

  • If std::is_arithmetic<T>::value is true, provides the member constant value equal to T(-1) < T(0).
  • Otherwise, provides the member constant value equal to 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 >
constexpr bool is_signed_v = is_signed<T>::value;
(since C++17)

Inherited from std::integral_constant

Member constants

value
[static]
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)
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_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

example.cpp
#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

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

checks if a type is an unsigned 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.