Namespaces
Variants
Views
Actions

Difference between revisions of "cpp/types/disjunction"

From cppreference.com
< cpp‎ | types
(→‎Possible implementation: Likewise)
m (→‎Possible implementation: fmt)
 
(27 intermediate revisions by 10 users not shown)
Line 1: Line 1:
 
{{cpp/title|disjunction}}
 
{{cpp/title|disjunction}}
−
{{cpp/types/navbar}}
+
{{cpp/meta/navbar}}
−
{{dcl begin}}
+
{{ddcl|header=type_traits|since=c++17|
−
{{dcl header | type_traits}}
+
template< class... B >
−
{{dcl | since=c++17 | num=1 | 1=
+
−
template<class... B>
+
 
struct disjunction;
 
struct disjunction;
 
}}
 
}}
−
{{dcl end}}
 
  
−
Forms the logical disjunction of the type traits {{tt|B...}} .
+
Forms the {{enwiki|Logical disjunction|logical disjunction}} of the type traits {{c|B...}}, effectively performing a logical OR on the sequence of traits.
  
−
The BaseCharacteristic of a specialization {{c|std::disjunction <B1, ..., BN>}} is the first {{tt|Bi}} for which {{c|1=Bi::value != false}}, or if every {{c|1=Bi::value == false}}, the BaseCharacteristic is {{tt|BN}}.
+
The specialization {{c|std::disjunction<B1, ..., BN>}} has a public and unambiguous base that is
 +
* if {{c|1=sizeof...(B) == 0}}, {{c|std::false_type}}; otherwise
 +
* the first type {{tt|Bi}} in {{tt|B1, ..., BN}} for which {{c|1=bool(Bi::value) == true}}, or {{tt|BN}} if there is no such type.
  
−
If {{c|1=sizeof...(B) == 0}}, the BaseCharacteristic is {{c|std::false_type}}.
+
The member names of the base class, other than {{tt|disjunction}} and {{tt|1=operator=}}, are not hidden and are unambiguously available in {{tt|disjunction}}.
  
−
Disjunction is short-circuiting: if there is a template type argument {{tt|Bi}} with {{c|1=Bi::value != false}}, then instantiating {{c|disjunction<B1, ..., BN>::value}} does not require the instantiation of {{c|Bj::value}} for {{tt|j > i}}
+
Disjunction is short-circuiting: if there is a template type argument {{tt|Bi}} with {{c|1=bool(Bi::value) != false}}, then instantiating {{c|disjunction<B1, ..., BN>::value}} does not require the instantiation of {{c|Bj::value}} for {{tt|j > i}}.
 +
 
 +
{{cpp/types/nospec|pv}}
  
 
===Template parameters===
 
===Template parameters===
 
{{par begin}}
 
{{par begin}}
−
{{par | B... | every type must be usable as a base class and define member {{c|B::value}} that is convertible to {{c|bool}} }}
+
{{par|B...|every template argument {{tt|Bi}} for which {{c|Bi::value}} is instantiated must be usable as a base class and define member {{tt|value}} that is convertible to {{c/core|bool}}}}
 
{{par end}}
 
{{par end}}
  
−
=== Helper variable template ===
+
===Helper variable template===
 
{{dcl begin}}
 
{{dcl begin}}
−
{{dcl | since=c++17 | 1=
+
{{dcl|since=c++17|1=
−
template<class... B>
+
template< class... B >
 
constexpr bool disjunction_v = disjunction<B...>::value;
 
constexpr bool disjunction_v = disjunction<B...>::value;
 
}}
 
}}
Line 32: Line 33:
 
===Possible implementation===
 
===Possible implementation===
 
{{eq fun
 
{{eq fun
−
| 1=
+
|1=
−
template<class...> struct disjunction : std::false_type { };
+
template<class...>
−
template<class B1> struct disjunction<B1> : B1 { };
+
struct disjunction : std::false_type {};
 +
 
 +
template<class B1>
 +
struct disjunction<B1> : B1 {};
 +
 
 
template<class B1, class... Bn>
 
template<class B1, class... Bn>
−
struct disjunction<B1, Bn...> : std::conditional_t<B1::value != false, B1, disjunction<Bn...>>  { };
+
struct disjunction<B1, Bn...>
 +
    : std::conditional_t<bool(B1::value), B1, disjunction<Bn...>>  {};
 
}}
 
}}
  
 
===Notes===
 
===Notes===
−
A specialization of disjunction does not necessarily have a BaseCharacteristic of either {{c|std::true_type}} or {{c|std::false_type}}: it simply inherits the base characteristic of the first B whose ::value, converted to bool, is true, or the base characteristic of the very last B when all of them convert to false. For example, {{c|std::disjunction<std::integral_constant<int, 2>, std::integral_constant<int, 4>>::value}} is {{c|2}}.
+
A specialization of {{tt|disjunction}} does not necessarily inherit from of either {{c|std::true_type}} or {{c|std::false_type}}: it simply inherits from the first {{tt|B}} whose {{tt|::value}}, explicitly converted to {{c/core|bool}}, is {{c|true}}, or from the very last {{tt|B}} when all of them convert to {{c|false}}. For example, {{c|std::disjunction<std::integral_constant<int, 2>, std::integral_constant<int, 4>>::value}} is {{c|2}}.
 +
 
 +
The short-circuit instantiation differentiates {{tt|disjunction}} from [[cpp/language/fold|fold expressions]]: a fold expression like {{c|(... {{!!}} Bs::value)}} instantiates every {{tt|B}} in {{tt|Bs}}, while {{c|std::disjunction_v<Bs...>}} stops instantiation once the value can be determined. This is particularly useful if the later type is expensive to instantiate or can cause a hard error when instantiated with the wrong type.
 +
 
 +
{{feature test macro|__cpp_lib_logical_traits|std=C++17|value=201510L|[[cpp/meta#Operations on traits|Logical operator type traits]]}}
  
 
===Example===
 
===Example===
−
{{example}}
+
{{example|code=
 +
#include <cstdint>
 +
#include <string>
 +
#include <type_traits>
 +
 
 +
// values_equal<a, b, T>::value is true if and only if 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 is always true
 +
template<typename T>
 +
struct default_type : std::true_type
 +
{
 +
    using type = T;
 +
};
 +
 
 +
// Now we can use disjunction like a switch statement:
 +
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>                        // must be last!
 +
    >::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>);
 +
 
 +
// checking if Foo is constructible from double will cause a hard error
 +
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> not instantiated
 +
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() {}
 +
|output=
 +
}}
  
 
===See also===
 
===See also===
 
{{dsc begin}}
 
{{dsc begin}}
−
{{dsc inc | cpp/types/dsc negation}}
+
{{dsc inc|cpp/types/dsc negation}}
−
{{dsc inc | cpp/types/dsc conjunction}}
+
{{dsc inc|cpp/types/dsc conjunction}}
 
{{dsc end}}
 
{{dsc end}}
  
−
[[de:cpp/types/disjunction]]
+
{{langlinks|de|es|fr|it|ja|pt|ru|zh}}
−
[[es:cpp/types/disjunction]]
+
−
[[fr:cpp/types/disjunction]]
+
−
[[it:cpp/types/disjunction]]
+
−
[[ja:cpp/types/disjunction]]
+
−
[[pt:cpp/types/disjunction]]
+
−
[[ru:cpp/types/disjunction]]
+
−
[[zh:cpp/types/disjunction]]
+

Latest revision as of 04:57, 24 September 2024

 
C++
 
Metaprogramming library
Type traits
Type categories
(C++11)
(C++14)  
(C++11)
(C++11)
(C++11)
(C++11)
(C++11)
(C++11)
(C++11)
(C++11)
(C++11)
(C++11)
(C++11)  
(C++11)
(C++11)
(C++11)
(C++11)
(C++11)
(C++11)
(C++11)
(C++11)
Type properties
(C++11)
(C++11)
(C++11)
(C++11)
(C++14)
(C++11)
(C++17)
(C++23)
(C++11)
(C++11)
(C++11)
(C++11)(until C++20*)
(C++11)(deprecated in C++20)
(C++11)
(C++11)
(C++20)
(C++20)
(C++23)
(C++17)
Type trait constants
(C++11)(C++17)(C++11)(C++11)
Metafunctions
(C++17)
disjunction
(C++17)
(C++17)
Supported operations
Relationships and property queries
Type modifications
(C++11)(C++11)(C++11)
(C++11)(C++11)(C++11)
(C++11)
(C++11)
Type transformations
(C++11)(deprecated in C++23)
(C++11)(deprecated in C++23)
(C++11)
(C++20)
(C++11)
(C++17)

(C++11)
(C++11)
(C++20)
(C++11)
(C++11)(until C++20*)(C++17)
(C++20)
Compile-time rational arithmetic
Compile-time integer sequences
(C++14)
 
Defined in header <type_traits>
template< class... B >
struct disjunction;
 (since C++17)

Forms the logical disjunction of the type traits B..., effectively performing a logical OR on the sequence of traits.

The specialization std::disjunction<B1, ..., BN> has a public and unambiguous base that is

  • if sizeof...(B) == 0, std::false_type; otherwise
  • the first type Bi in B1, ..., BN for which bool(Bi::value) == true, or BN if there is no such type.

The member names of the base class, other than disjunction and operator=, are not hidden and are unambiguously available in disjunction.

Disjunction is short-circuiting: if there is a template type argument Bi with bool(Bi::value) != false, then instantiating disjunction<B1, ..., BN>::value does not require the instantiation of Bj::value for j > i.

If the program adds specializations for std::disjunction or std::disjunction_v, the behavior is undefined.

Contents

[edit] Template parameters

B... - every template argument Bi for which Bi::value is instantiated must be usable as a base class and define member value that is convertible to bool

[edit] Helper variable template

template< class... B >
constexpr bool disjunction_v = disjunction<B...>::value;
 (since C++17)

[edit] Possible implementation

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...>>  {};

[edit] Notes

A specialization of disjunction does not necessarily inherit from of either std::true_type or std::false_type: it simply inherits from the first B whose ::value, explicitly converted to bool, is true, or from the very last B when all of them convert to false. For example, std::disjunction<std::integral_constant<int, 2>, std::integral_constant<int, 4>>::value is 2.

The short-circuit instantiation differentiates disjunction from fold expressions: a fold expression like (... || Bs::value) instantiates every B in Bs, while std::disjunction_v<Bs...> stops instantiation once the value can be determined. This is particularly useful if the later type is expensive to instantiate or can cause a hard error when instantiated with the wrong type.

Feature-test macro Value Std Feature
__cpp_lib_logical_traits 201510L (C++17) Logical operator type traits

[edit] Example

Run this code
#include <cstdint>
#include <string>
#include <type_traits>
 
// values_equal<a, b, T>::value is true if and only if 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 is always true
template<typename T>
struct default_type : std::true_type
{
    using type = T;
};
 
// Now we can use disjunction like a switch statement:
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>                         // must be last!
    >::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>);
 
// checking if Foo is constructible from double will cause a hard error
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> not instantiated
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() {}

[edit] See also

(C++17)
 logical NOT metafunction
(class template) [edit]
(C++17)
 variadic logical AND metafunction
(class template) [edit]
Retrieved from "https://en.cppreference.com/mwiki/index.php?title=cpp/types/disjunction&oldid=176422"