std::disjunction
| Определено в заголовочном файле <type_traits>
|
||
template< class... B > struct disjunction; |
(начиная с C++17) | |
Формирует логическую дизъюнкцию свойств типа B..., эффективно выполняя логическое ИЛИ над последовательностью свойств.
Специализация std::disjunction<B1, ..., BN> имеет открытый и недвусмысленный базовый класс, т.е.
- если
sizeof...(B) == 0,std::false_type; иначе - первый тип
BiвB1, ..., BN, для которогоbool(Bi::value) == true, илиBN, если такого типа нет.
Имена элементов базового класса, отличные от disjunction и operator=, не скрыты и однозначно доступны в disjunction.
Дизъюнкция является коротким замыканием: если есть аргумент типа шаблона Bi с bool(Bi::value) != false, то создание экземпляра disjunction<B1, ..., BN>::value не требует создания экземпляра Bj::value для j > i.
Поведение программы, добавляющей специализации для std::disjunction или std::disjunction_v не определено.
Параметры шаблона
| B... | — | каждый аргумент шаблона Bi, для которого создаётся экземпляр Bi::value, должен использоваться в качестве базового класса и определять элемент value, который может быть преобразован в bool
|
Шаблон вспомогательной переменной
<tbody> </tbody> template< class... B > inline constexpr bool disjunction_v = disjunction<B...>::value; |
(начиная с C++17) | |
Возможная реализация
template<class...> struct disjunction : std::false_type { };
template<class B1> struct disjunction<B1> : B1 { };
template<class B1, class... Bn>
struct disjunction<B1, Bn...>
: std::conditional_t<bool(B1::value), B1, disjunction<Bn...>> { };
|
Примечание
Специализация disjunction не обязательно наследуется либо от std::true_type, либо от std::false_type: она просто наследуется от первого B чьё ::value, явно преобразованное в bool, равно true, или от самого последнего B, когда все они преобразуются в false. Например, std::disjunction<std::integral_constant<int, 2>, std::integral_constant<int, 4>>::value равно 2.
Создание экземпляра короткого замыкания отличает disjunction от выражений свёртки: выражение свёртки, подобное (... || Bs::value), инстанцирует каждый B в Bs, а std::disjunction_v<Bs...> останавливает создание экземпляра, как только значение может быть определено. Это особенно полезно, если более поздний тип требует больших затрат для создания экземпляра или может вызвать серьёзную ошибку при создании экземпляра с неправильным типом.
| Макрос Тестирования функциональности | Значение | Стандарт | Функциональность |
|---|---|---|---|
__cpp_lib_logical_traits |
201510L |
(C++17) | Свойства типа логического оператора |
Пример
#include <cstdint>
#include <string>
#include <type_traits>
// values_equal<a, b, T>::value истинно тогда и только тогда, когда a == b.
template <auto V1, decltype(V1) V2, typename T>
struct values_equal : std::bool_constant<V1 == V2> {
using type = T;
};
// default_type<T>::value всегда истинно
template <typename T>
struct default_type : std::true_type {
using type = T;
};
// Теперь мы можем использовать дизъюнкцию как оператор switch:
template <int I>
using int_of_size = typename std::disjunction< //
values_equal<I, 1, std::int8_t>, //
values_equal<I, 2, std::int16_t>, //
values_equal<I, 4, std::int32_t>, //
values_equal<I, 8, std::int64_t>, //
default_type<void> // должен быть последним!
>::type;
static_assert(sizeof(int_of_size<1>) == 1);
static_assert(sizeof(int_of_size<2>) == 2);
static_assert(sizeof(int_of_size<4>) == 4);
static_assert(sizeof(int_of_size<8>) == 8);
static_assert(std::is_same_v<int_of_size<13>, void>);
// проверка того, можно ли создать Foo из double, вызовет серьёзную ошибку
struct Foo {
template<class T>
struct sfinae_unfriendly_check { static_assert(!std::is_same_v<T, double>); };
template<class T>
Foo(T, sfinae_unfriendly_check<T> = {} );
};
template<class... Ts>
struct first_constructible {
template<class T, class...Args>
struct is_constructible_x : std::is_constructible<T, Args...> {
using type = T;
};
struct fallback {
static constexpr bool value = true;
using type = void; // type to return if nothing is found
};
template<class... Args>
using with = typename std::disjunction<is_constructible_x<Ts, Args...>...,
fallback>::type;
};
// OK, is_constructible<Foo, double> не создаётся
static_assert(std::is_same_v<first_constructible<std::string, int, Foo>::with<double>,
int>);
static_assert(std::is_same_v<first_constructible<std::string, int>::with<>, std::string>);
static_assert(std::is_same_v<first_constructible<std::string, int>::with<const char*>,
std::string>);
static_assert(std::is_same_v<first_constructible<std::string, int>::with<void*>, void>);
int main()
{
}
Смотрите также
(C++17) |
логическая метафункция НЕ (шаблон класса) |
(C++17) |
вариативная логическая метафункция И (шаблон класса) |