std::experimental::is_detected, std::experimental::detected_t, std::experimental::detected_or

 

C++

Поддержка компилятором

Автономные и размещённые реализации

Язык

Стандартная библиотека

Заголовки стандартной библиотеки

Требования к именованию

Макросы тестирования функциональности (C++20)

Поддержка языка

Библиотека концептов (C++20)

Библиотека метапрограммирования (C++11)

Библиотека диагностики

Библиотека общих утилит

Библиотека строк

Библиотека контейнеров

Библиотека итераторов

Библиотека диапазонов (C++20)

Библиотека алгоритмов

Библиотека численных данных

Библиотека ввода/вывода

Библиотека локализаций

Регулярные выражения (C++11)

Атомарные операции (C++11)

Библиотека поддержки конкуренции (C++11)

Библиотека файловой системы (C++17)

Технические спецификации

Указатель символов

Внешние библиотеки

 

Технические спецификации

Библиотека файловой системы (ТС файловой системы)

Основы библиотеки (ТС основ библиотеки)

Основы библиотеки 2 (ТС основ библиотеки v2)

Основы библиотеки 3 (ТС основы библиотеки v3)

Расширения для параллелизма (ТС параллелизма)

Расширения для параллелизма 2 (ТС параллелизма v2)

Расширения для конкуренции 2 (ТС конкуренции v2)

Концепты (ТС концепций)

Диапазоны (ТС диапазонов)

Рефлексия (ТС рефлексии)

Специальные математические функции (ТО специальные функции)

 

Основы библиотеки v2

experimental::propagate_const

experimental::not_fn

experimental::observer_ptr

experimental::make_array

experimental::to_array

experimental::ostream_joiner

experimental::gcd

experimental::lcm

experimental::source_location

experimental::randint

идиома обнаружения

единообразная очистка контейнера

свойства типа логического оператора

 

<tbody> </tbody>

Определено в заголовочном файле <experimental/type_traits>
template< template<class...> class Op, class... Args > using is_detected = /* смотрите ниже */;		(ТС основ библиотеки v2)
template< template<class...> class Op, class... Args > using detected_t = /* смотрите ниже */;		(ТС основ библиотеки v2)
template< class Default, template<class...> class Op, class... Args > using detected_or = /* смотрите ниже */;		(ТС основ библиотеки v2)

Псевдоним шаблона detected_or это псевдоним для неопределённого типа класса с двумя общедоступными определениями типов элементов value_t и type, которые определены следующим образом:

• Если идентификатор шаблона Op<Args...> обозначает допустимый тип, то value_t является псевдонимом для std::true_type, а type псевдоним для Op<Args...>;
• В противном случае value_t это псевдоним для std::false_type, а type псевдоним для Default.

Псевдоним шаблона is_detected эквивалентен typename detected_or<std::experimental::nonesuch, Op, Args...>::value_t. Это псевдоним для std::true_type, если идентификатор шаблона Op<Args...> обозначает допустимый тип; в противном случае это псевдоним для std::false_type.

Псевдоним шаблона detected_t эквивалентен typename detected_or<std::experimental::nonesuch, Op, Args...>::type. Это псевдоним для Op<Args...>, если идентификатор шаблона обозначает допустимый тип; в противном случае это псевдоним для класса std::experimental::nonesuch.

Дополнительные утилиты

<tbody> </tbody> <tbody class="t-dcl-rev "> </tbody><tbody> </tbody> <tbody class="t-dcl-rev "> </tbody><tbody> </tbody> <tbody class="t-dcl-rev "> </tbody><tbody> </tbody>

template< template<class...> class Op, class... Args > constexpr bool is_detected_v = is_detected<Op, Args...>::value;		(ТС основ библиотеки v2)
template< template<class...> class Op, class... Args > constexpr inline bool is_detected_v = is_detected<Op, Args...>::value;		(ТС основы библиотеки v3)
template< class Default, template<class...> class Op, class... Args > using detected_or_t = typename detected_or<Default, Op, Args...>::type;		(ТС основ библиотеки v2)
template <class Expected, template<class...> class Op, class... Args> using is_detected_exact = std::is_same<Expected, detected_t<Op, Args...>>;		(ТС основ библиотеки v2)
template <class Expected, template<class...> class Op, class... Args> constexpr bool is_detected_exact_v = is_detected_exact<Expected, Op, Args...>::value;		(ТС основ библиотеки v2)
template <class Expected, template<class...> class Op, class... Args> constexpr inline bool is_detected_exact_v = is_detected_exact<Expected, Op, Args...>::value;		(ТС основы библиотеки v3)
template <class To, template<class...> class Op, class... Args> using is_detected_convertible = std::is_convertible<detected_t<Op, Args...>, To>;		(ТС основ библиотеки v2)
template <class To, template<class...> class Op, class... Args> constexpr bool is_detected_convertible_v = is_detected_convertible<To, Op, Args...>::value;		(ТС основ библиотеки v2)
template <class To, template<class...> class Op, class... Args> constexpr inline bool is_detected_convertible_v = is_detected_convertible<To, Op, Args...>::value;		(ТС основы библиотеки v3)

Псевдоним шаблона is_detected_exact проверяет, равны ли detected_t<Op, Args...> и Expected.

Псевдоним шаблона is_detected_convertible проверяет, можно ли преобразовать detected_t<Op, Args...> в To.

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

namespace detail {
template <class Default, class AlwaysVoid,
          template<class...> class Op, class... Args>
struct detector {
  using value_t = std::false_type;
  using type = Default;
};

template <class Default, template<class...> class Op, class... Args>
struct detector<Default, std::void_t<Op<Args...>>, Op, Args...> {
  using value_t = std::true_type;
  using type = Op<Args...>;
};

} // пространство имён detail

template <template<class...> class Op, class... Args>
using is_detected = typename detail::detector<nonesuch, void, Op, Args...>::value_t;

template <template<class...> class Op, class... Args>
using detected_t = typename detail::detector<nonesuch, void, Op, Args...>::type;

template <class Default, template<class...> class Op, class... Args>
using detected_or = detail::detector<Default, void, Op, Args...>;

Пример

Запустить этот код

#include <experimental/type_traits>
#include <cstddef>

template<class T>
using copy_assign_t = decltype(std::declval<T&>() = std::declval<const T&>());

struct Meow { };
struct Purr { void operator=(const Purr&) = delete; };
 
static_assert(std::experimental::is_detected<copy_assign_t, Meow>::value,
              "Meow должен быть копируем присваиванием!");
static_assert(!std::experimental::is_detected_v<copy_assign_t, Purr>,
              "Purr не должно быть копируем присваиванием!");
static_assert(std::experimental::is_detected_exact_v<Meow&, copy_assign_t, Meow>,
              "Копирование присваиванием Meow должно вернуть Meow&!");

template<class T>
using diff_t = typename T::difference_type;

template <class Ptr>
using difference_type = std::experimental::detected_or_t<std::ptrdiff_t, diff_t, Ptr>;

struct Woof { using difference_type = int; };
struct Bark {};

static_assert(std::is_same<difference_type<Woof>, int>::value,
              "difference_type Woof'а должно быть int!");
static_assert(std::is_same<difference_type<Bark>, std::ptrdiff_t>::value,
              "difference_type Bark'а должно быть ptrdiff_t!");

int main() {}