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

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

• ifsizeof...(B)==0,std::true_type; otherwise
• the first typeBi inB1, ..., BN for whichbool(Bi::value)==false, orBN if there is no such type.

The member names of the base class, other thanconjunction andoperator=, are not hidden and are unambiguously available inconjunction.

Conjunction is short-circuiting: if there is a template type argumentBi withbool(Bi::value)==false, then instantiatingconjunction<B1, ..., BN>::value does not require the instantiation ofBj::value forj > i.

If the program adds specializations forstd::conjunction orstd::conjunction_v, the behavior is undefined.

[edit]Template parameters

[edit]Helper variable template

[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 ofconjunction does not necessarily inherit from eitherstd::true_type orstd::false_type: it simply inherits from the firstB whose::value, explicitly converted tobool, isfalse, or from the very lastB when all of them convert totrue. For example,std::conjunction<std::integral_constant<int,2>,std::integral_constant<int,4>>::value is4.

The short-circuit instantiation differentiatesconjunction fromfold expressions: a fold expression, like(...&& Bs::value), instantiates everyB inBs, whilestd::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.

[edit]Example

#include <iostream>#include <type_traits> // func is enabled if all Ts... have the same type as Ttemplate<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";} // otherwisetemplate<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>constexprbool 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!");}

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

[edit]See also

• In other languages

• Deutsch
• Español
• Français
• Italiano
• 日本語
• Português
• Русский
• 中文