std::is_pointer — cppreference.com

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


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

std::is_pointer является UnaryTypeTrait.

Проверяет, является ли T указателем на объект или функцию (включая указатель на void, но исключая указатель на элемент) или их cv-квалифицированную версию. Предоставляет константу-элемент value, которая равна true, если T является типом указателя на объект или функцию. Иначе value равна false.

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

Параметры шаблона

Шаблон вспомогательной переменной

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

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

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

true, если T это тип указателя, false иначе
(public static константа-элемент)

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

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

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


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

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

template<class T>
struct is_pointer : std::false_type {};

template<class T>
struct is_pointer<T*> : std::true_type {};

template<class T>
struct is_pointer<T* const> : std::true_type {};

template<class T>
struct is_pointer<T* volatile> : std::true_type {};

template<class T>
struct is_pointer<T* const volatile> : std::true_type {};

Пример

#include <type_traits>

int main()
{
    struct A
    {
        int m;
        void f() {}
    };

    int A::*mem_data_ptr = &A::m;     // указатель на элемент данных
    void (A::*mem_fun_ptr)() = &A::f; // указатель на функцию-элемент

    static_assert(
           ! std::is_pointer<A>::value
        && ! std::is_pointer_v<A>    // то же самое, что и выше, но в С++17!
        && ! std::is_pointer<A>()    // то же, что и выше, с использованием
                                     // унаследованного operator bool
        && ! std::is_pointer<A>{}    // то же самое
        && ! std::is_pointer<A>()()  // то же, что и выше, с использованием
                                     // унаследованного operator()
        && ! std::is_pointer<A>{}()  // то же самое
        &&   std::is_pointer_v<A*>
        &&   std::is_pointer_v<A const* volatile>
        && ! std::is_pointer_v<A&>
        && ! std::is_pointer_v<decltype(mem_data_ptr)>
        && ! std::is_pointer_v<decltype(mem_fun_ptr)>
        &&   std::is_pointer_v<void*>
        && ! std::is_pointer_v<int>
        &&   std::is_pointer_v<int*>
        &&   std::is_pointer_v<int**>
        && ! std::is_pointer_v<int[10]>
        && ! std::is_pointer_v<std::nullptr_t>
        &&   std::is_pointer_v<void (*)()>
    );
}

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

Категории: