std::is_same (3) - Linux Man Pages

std::is_same: std::is_same


std::is_same - std::is_same


Defined in header <type_traits>
template< class T, class U > (since C++11)
struct is_same;

If T and U name the same type (including const/volatile qualifications), provides the member constant value equal to true. Otherwise value is false.
Commutativity is satisfied, i.e. for any two types T and U, is_same<T, U>::value == true if and only if is_same<U, T>::value == true.

Helper variable template

template< class T, class U > (since C++17)
inline constexpr bool is_same_v = is_same<T, U>::value;

Inherited from std::integral_constant

Member constants

value true if T and U is the same type , false otherwise
         (public static member constant)

Member functions

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

operator() returns value
              (public member function)

Member types

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

Possible implementation

  template<class T, class U>
  struct is_same : std::false_type {};

  template<class T>
  struct is_same<T, T> : std::true_type {};


// Run this code

  #include <iostream>
  #include <type_traits>
  #include <cstdint>

  void print_separator()
      std::cout << "-----\n";

  int main()
      std::cout << std::boolalpha;

      // some implementation-defined facts
      std::cout << std::is_same<int, std::int32_t>::value << '\n';
      // usually true if 'int' is 32 bit
      std::cout << std::is_same<int, std::int64_t>::value << '\n';
      // possibly true if ILP64 data model is used


      // 'float' is never an integral type
      std::cout << std::is_same<float, std::int32_t>::value << '\n'; // false


      // 'int' is implicitly 'signed'
      std::cout << std::is_same<int, int>::value << "\n"; // true
      std::cout << std::is_same<int, unsigned int>::value << "\n"; // false
      std::cout << std::is_same<int, signed int>::value << "\n"; // true


      // unlike other types, 'char' is neither 'unsigned' nor 'signed'
      std::cout << std::is_same<char, char>::value << "\n"; // true
      std::cout << std::is_same<char, unsigned char>::value << "\n"; // false
      std::cout << std::is_same<char, signed char>::value << "\n"; // false

Possible output:


See also

is_integral checks if a type is an integral type
              (class template)

make_signed makes the given integral type signed
              (class template)

make_unsigned makes the given integral type unsigned
              (class template)