Difference between revisions of "cpp/types/conjunction"
(+) |
m (mention sizeof... zero case) |
||
| Line 12: | Line 12: | ||
The BaseCharacteristic of a specialization {{c|std::conjunction<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 BaseCharacteristic of a specialization {{c|std::conjunction<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}}. | ||
| + | |||
| + | If {{c|1=sizeof...(B) == 0}}, the BaseCharacteristic is {{c|std::true_type}}. | ||
Conjunction is short-circuiting: if there is a template type argument {{tt|Bi}} with {{c|1=Bi::value == false}}, then instantiating {{c|conjunction<B1, ..., BN>::value}} does not require the instantiation of {{c|Bj::value}} for {{tt|j > i}} | Conjunction is short-circuiting: if there is a template type argument {{tt|Bi}} with {{c|1=Bi::value == false}}, then instantiating {{c|conjunction<B1, ..., BN>::value}} does not require the instantiation of {{c|Bj::value}} for {{tt|j > i}} | ||
Revision as of 07:14, 28 October 2015
| Defined in header <type_traits>
|
||
| template<class... B> struct conjunction; |
(1) | (since C++17) |
Forms the logical conjunction of the type traits B....
The BaseCharacteristic of a specialization std::conjunction<B1, ..., BN> is the first Bi for which Bi::value == false, or if every Bi::value != false, the BaseCharacteristic is BN.
If sizeof...(B) == 0, the BaseCharacteristic is std::true_type.
Conjunction is short-circuiting: if there is a template type argument Bi with Bi::value == false, then instantiating conjunction<B1, ..., BN>::value does not require the instantiation of Bj::value for j > i
Contents |
Template parameters
| B... | - | every type must be usable as a base class and define member B::value that is convertible to bool |
Helper variable template
| template<class... B> constexpr bool conjunction_v = conjunction<B...>::value; |
(since C++17) | |
Inherited from std::integral_constant
Member constants
| value [static] |
true if if all B::value are true , false otherwise (public static member constant) |
Member functions
| operator bool |
converts the object to bool, returns value (public member function) |
| operator() (C++14) |
returns value (public member function) |
Member types
| Type | Definition |
value_type
|
bool |
type
|
std::integral_constant<bool, value> |
Possible implementation
template<class...> struct conjunction; // not defined template<> struct conjunction<> : std::true_type { }; template<class B1> struct conjunction<B1> : B1 { }; template<class B1, class B2> struct conjunction<B1, B2> : std::conditional_t<B1::value, B2, B1> {}; template<class B1, class B2, class B3, class... Bn> struct conjunction<B1, B2, B3, Bn...> : std::conditional_t<B1::value, conjunction<B2, B3, Bn...>, B1> {}; |
Notes
A specialization of conjunction does not necessarily have a BaseCharacteristic of either std::true_type or std::false_type: it simply inherits the base characteristic of the first B whose ::value, converted to bool, is false, or the base characteristic of the very last B when all of them convert to true. For example, std::conjunction<std::integral_constant<int, 2>, std::integral_constant<int, 4>>::value is 4.
Example
// func is enabled if all Ts... have the same type template<typename T, typename... Ts> std::enable_if_t<std::conjunction_v<std::is_same<T, Ts>...> > func(T, Ts...) { // TODO somethng to show }
See also
| (C++17) |
logical NOT metafunction (class template) |
| (C++17) |
variadic logical OR metafunction (class template) |
