std::is_same — cppreference.com

Материал из cppreference.com


`template< class T, class U > struct is_same;`		(начиная с C++11)

Если T и U именуют один и тот же тип (принимая во внимание квалификацию const/volatile), предоставляет константу-элемент value, равную true. Иначе value равна false.

Коммутативность выполняется, т.е. для любых двух типов T и U, is_same<T, U>::value == true, если и только если is_same<U, T>::value == true.

Поведение программы, добавляющей специализации для std::is_same или std::is_same_v (начиная с C++17) не определено.

Вспомогательная шаблонная переменная

`template< class T, class U > inline constexpr bool is_same_v = is_same<T, U>::value;`		(начиная с C++17)

Унаследован от std::integral_constant

Константы элементы

true, если T и U одного типа , false иначе
(public static константа-элемент)

Функции-элементы

	преобразует объект в `bool`, возвращает `value` (public функция-элемент)
	возвращает `value` (public функция-элемент)

Типы элементы


Тип	Определение
`value_type`	`bool`
`type`	`std::integral_constant<bool, value>`

Возможная реализация

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

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

Пример

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

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

    // некоторые факты, определяемые реализацией

    // обычно true, если 'int' 32-битный
    std::cout << std::is_same<int, std::int32_t>::value << ' '; // возможно true
    // возможно true, если используется модель данных ILP64
    std::cout << std::is_same<int, std::int64_t>::value << ' '; // возможно false

    // те же тесты, что и выше, за исключением использования формата C++17
    // std::is_same_v<T, U> format
    std::cout << std::is_same_v<int, std::int32_t> << ' ';  // возможно true
    std::cout << std::is_same_v<int, std::int64_t> << '\n'; // возможно false

    // сравнивает типы пары переменных
    long double num1 = 1.0;
    long double num2 = 2.0;
    static_assert( std::is_same_v<decltype(num1), decltype(num2)> == true );

    // 'float' никогда не является целочисленным типом
    static_assert( std::is_same<float, std::int32_t>::value == false );

    // 'int' неявно 'знаковый'
    static_assert( std::is_same_v<int, int> == true );
    static_assert( std::is_same_v<int, unsigned int> == false );
    static_assert( std::is_same_v<int, signed int> == true );

    // в отличие от других типов, 'char' не является ни 'без знаковым', ни 'знаковым'
    static_assert( std::is_same_v<char, char> == true );
    static_assert( std::is_same_v<char, unsigned char> == false );
    static_assert( std::is_same_v<char, signed char> == false );

    // const-квалифицированный тип T не совпадает с неконстантным T
    static_assert( !std::is_same<const int, int>() );
}

Возможный вывод:

Смотрите также

Категории: