Namespaces
Variants
Views
Actions

Difference between revisions of "cpp/types/conjunction"

From cppreference.com
< cpp‎ | types
m (→‎Possible implementation)
m (fmt.)
 
(26 intermediate revisions by 11 users not shown)
Line 1: Line 1:
 
{{cpp/title|conjunction}}
 
{{cpp/title|conjunction}}
−
{{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 conjunction;
 
struct conjunction;
 
}}
 
}}
−
{{dcl end}}
 
  
−
Forms the logical conjunction of the type traits {{tt|B...}}.
+
Forms the {{enwiki|logical conjunction}} of the type traits {{c|B...}}, effectively performing a logical AND on the sequence of traits.
  
−
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 specialization {{c|std::conjunction<B1, ..., BN>}} has a public and unambiguous base that is
 +
* if {{c|1=sizeof...(B) == 0}}, {{c|std::true_type}}; otherwise
 +
* the first type {{tt|Bi}} in {{tt|B1, ..., BN}} for which {{c|1=bool(Bi::value) == false}}, or {{tt|BN}} if there is no such type.
  
−
If {{c|1=sizeof...(B) == 0}}, the BaseCharacteristic is {{c|std::true_type}}.
+
The member names of the base class, other than {{tt|conjunction}} and {{tt|1=operator=}}, are not hidden and are unambiguously available in {{tt|conjunction}}.
  
−
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= bool(Bi::value) == false}}, then instantiating {{c|conjunction<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}}
+
{{ddcl|since=c++17|1=
−
{{dcl | since=c++17 | 1=
+
template< class... B >
−
template<class... B>
+
 
constexpr bool conjunction_v = conjunction<B...>::value;
 
constexpr bool conjunction_v = conjunction<B...>::value;
 
}}
 
}}
−
{{dcl end}}
 
  
 
===Possible implementation===
 
===Possible implementation===
 
{{eq fun
 
{{eq fun
−
| 1=
+
|1=
−
template<class...> struct conjunction : std::true_type { };
+
template<class...>
−
template<class B1> struct conjunction<B1> : B1 { };
+
struct conjunction : std::true_type {};
 +
 
 +
template<class B1>
 +
struct conjunction<B1> : B1 {};
 +
 
 
template<class B1, class... Bn>
 
template<class B1, class... Bn>
−
struct conjunction<B1, Bn...> : std::conditional_t<B1::value, conjunction<Bn...>, B1> {};
+
struct conjunction<B1, Bn...>
 +
    : std::conditional_t<bool(B1::value), conjunction<Bn...>, B1> {};
 
}}
 
}}
  
 
===Notes===
 
===Notes===
−
A specialization of conjunction 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 false, or the base characteristic of the very last B when all of them convert to true. For example, {{c|std::conjunction<std::integral_constant<int, 2>, std::integral_constant<int, 4>>::value}} is {{c|4}}.
+
A specialization of {{tt|conjunction}} does not necessarily inherit from 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|false}}, or from the very last {{tt|B}} when all of them convert to {{c|true}}. For example, {{c|std::conjunction<std::integral_constant<int, 2>, std::integral_constant<int, 4>>::value}} is {{c|4}}.
 +
 
 +
The short-circuit instantiation differentiates {{tt|conjunction}} from [[cpp/language/fold|fold expressions]]: a fold expression, like {{c|(... && Bs::value)}}, instantiates every {{tt|B}} in {{tt|Bs}}, while {{c|std::conjunction_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|code=
+
{{example
−
// func is enabled if all Ts... have the same type
+
|code=
 +
#include <iostream>
 +
#include <type_traits>
 +
 
 +
// func is enabled if all Ts... have the same type as T
 
template<typename T, typename... Ts>
 
template<typename T, typename... Ts>
−
std::enable_if_t<std::conjunction_v<std::is_same<T, Ts>...> >
+
std::enable_if_t<std::conjunction_v<std::is_same<T, Ts>...>>
−
func(T, Ts...) {
+
func(T, Ts...)
−
// TODO somethng to show
+
{
 +
    std::cout << "All types in pack are the same.\n";
 +
}
 +
 
 +
// otherwise
 +
template<typename T, typename... Ts>
 +
std::enable_if_t<!std::conjunction_v<std::is_same<T, Ts>...>>
 +
func(T, Ts...)
 +
{
 +
    std::cout << "Not all types in pack are the same.\n";
 +
}
 +
 
 +
template<typename T, typename... Ts>
 +
constexpr bool all_types_are_same = std::conjunction_v<std::is_same<T, Ts>...>;
 +
 
 +
static_assert(all_types_are_same<int, int, int>);
 +
static_assert(not all_types_are_same<int, int&, int>);
 +
 
 +
int main()
 +
{
 +
    func(1, 2, 3);
 +
    func(1, 2, "hello!");
 
}
 
}
 +
|output=
 +
All types in pack are the same.
 +
Not all types in pack are the same.
 
}}
 
}}
  
 
===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 disjunction}}
+
{{dsc inc|cpp/types/dsc disjunction}}
 
{{dsc end}}
 
{{dsc end}}
  
−
[[de:cpp/types/conjunction]]
+
{{langlinks|de|es|fr|it|ja|pt|ru|zh}}
−
[[es:cpp/types/conjunction]]
+
−
[[fr:cpp/types/conjunction]]
+
−
[[it:cpp/types/conjunction]]
+
−
[[ja:cpp/types/conjunction]]
+
−
[[pt:cpp/types/conjunction]]
+
−
[[ru:cpp/types/conjunction]]
+
−
[[zh:cpp/types/conjunction]]
+

Latest revision as of 05:03, 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
conjunction
(C++17)
(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 conjunction;
 (since C++17)

Forms the logical conjunction of the type traits B..., effectively performing a logical AND on the sequence of traits.

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

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

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

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

If the program adds specializations for std::conjunction or std::conjunction_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 conjunction_v = conjunction<B...>::value;
 (since C++17)

[edit] Possible implementation

template<class...>
struct conjunction : std::true_type {};
 
template<class B1>
struct conjunction<B1> : B1 {};
 
template<class B1, class... Bn>
struct conjunction<B1, Bn...>
    : std::conditional_t<bool(B1::value), conjunction<Bn...>, B1> {};

[edit] Notes

A specialization of conjunction does not necessarily inherit from either std::true_type or std::false_type: it simply inherits from the first B whose ::value, explicitly converted to bool, is false, or from 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.

The short-circuit instantiation differentiates conjunction from fold expressions: a fold expression, like (... && Bs::value), instantiates every B in Bs, while std::conjunction_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 <iostream>
#include <type_traits>
 
// func is enabled if all Ts... have the same type as T
template<typename T, typename... Ts>
std::enable_if_t<std::conjunction_v<std::is_same<T, Ts>...>>
func(T, Ts...)
{
    std::cout << "All types in pack are the same.\n";
}
 
// otherwise
template<typename T, typename... Ts>
std::enable_if_t<!std::conjunction_v<std::is_same<T, Ts>...>>
func(T, Ts...)
{
    std::cout << "Not all types in pack are the same.\n";
}
 
template<typename T, typename... Ts>
constexpr bool all_types_are_same = std::conjunction_v<std::is_same<T, Ts>...>;
 
static_assert(all_types_are_same<int, int, int>);
static_assert(not all_types_are_same<int, int&, int>);
 
int main()
{
    func(1, 2, 3);
    func(1, 2, "hello!");
}

Output: 

All types in pack are the same.
Not all types in pack are the same.

[edit] See also

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