◐ Shell
clean mode source ↗

std::is_same - cppreference.com

De cppreference.com

template< class T, class U > struct is_same;

 (desde C++11)

Si T y U denominan el mismo tipo (tomando en cuenta las calificaciones const/volatile), proporciona la constante miembro value igual a true. De lo contrario, value es false.

Se satisface la conmutatividad, es decir, para dos tipos cualesquiera T y U, is_same<T, U>::value == true si y solo si is_same<U, T>::value == true.

El comportamiento de un programa que añade especializaciones para is_same o is_same_v (desde C++17) no está definido.

Plantilla de variable auxiliar

template< class T, class U > inline constexpr bool is_same_v = is_same<T, U>::value;

 (desde C++17)

Heredado de std::integral_constant

Constantes miembro

true si T y U son el mismo tipo , de lo contrario false.
(constante miembro pública estática)

Funciones miembro

Convierte el objeto a bool, devuelve value.
(función miembro pública)
Devuelve value.
(función miembro pública)

Tipos miembro

Tipo Definición
value_type bool
type std::integral_constant<bool, value>

Posible implementación

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

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

Ejemplo

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

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

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

    // algunos hechos definidos por la implementación
    std::cout << std::is_same<int, std::int32_t>::value << '\n';
    // habitualmente verdadero si 'int' es 32 bit
    std::cout << std::is_same<int, std::int64_t>::value << '\n';
    // posiblemente verdadero si se usa el modelo de datosILP64

    print_separator();

    // 'float' nunca es un tipo entero
    std::cout << std::is_same<float, std::int32_t>::value << '\n'; // falso

    print_separator();

    // 'int' es implícitamente 'signed'
    std::cout << std::is_same<int, int>::value << "\n";          // verdadero
    std::cout << std::is_same<int, unsigned int>::value << "\n"; // falso
    std::cout << std::is_same<int, signed int>::value << "\n";   // verdadero

    print_separator();

    // a diferencia de otros tipos, 'char' no es ni 'unsigned' ni 'signed'
    std::cout << std::is_same<char, char>::value << "\n";          // verdadero
    std::cout << std::is_same<char, unsigned char>::value << "\n"; // falso
    std::cout << std::is_same<char, signed char>::value << "\n";   // falso
}

Posible salida: 

true
false
-----
false
-----
true
false
true
-----
true
false
false

Véase también