std::experimental::ranges::common_reference
Defined in header <experimental/ranges/type_traits>


template< class... T > struct common_reference; 
(ranges TS)  
Determines the common reference type of the types T...
, that is, the type to which all the types in T...
can be converted or bound. If such a type exists (as determined according to the rules below), the member type
names that type. Otherwise, there is no member type
. The behavior is undefined if any of the types in T...
is an incomplete type other than (possibly cvqualified) void.
When given reference types, common_reference
attempts to find a reference type to which the supplied reference types can all be bound, but may return a nonreference type if it cannot find such a reference type.
 If sizeof...(T) is zero, there is no member
type
.  If sizeof...(T) is one (i.e.,
T...
contains only one typeT0
), the membertype
names the same type as T0.  If sizeof...(T) is two (i.e.,
T...
contains two typesT1
andT2
): If
T1
andT2
are both reference types, and the simple common reference typeS
ofT1
andT2
(as defined below) exists, then the member typetype
namesS
;  Otherwise, if basic_common_reference<T1R, T2R, T1Q, T2Q>::type exists, where
TiR
is std::remove_cv_t<std::remove_reference_t<Ti>> andTiQ
is an alias template such that TiQ<TiR> is Ti, then the member typetype
names that type;  Otherwise, if decltype(false? val<T1>() : val<T2>()), where
val
is a function template template<class T> T val();, denotes a valid type, then the member typetype
names that type;  Otherwise, if ranges::common_type_t<T1, T2> is a valid type, then the member type
type
names that type;  Otherwise, there is no member type.
 If
 If sizeof...(T) is greater than two (i.e.,
T...
consists of the typesT1, T2, R...
), then if ranges::common_reference_t<T1, T2> exists, the membertype
denotes ranges::common_reference_t<ranges::common_reference_t<T1, T2>, R...> if such a type exists. In all other cases, there is no membertype
.
The simple common reference type of two reference types T1
and T2
is defined as follows:
 If
T1
iscv1 X &
andT2
iscv2 Y &
(i.e., both are lvalue reference types): their simple common reference type is decltype(false? std::declval<cv12 X &>() : std::declval<cv12 Y &>()), where cv12 is the union of cv1 and cv2, if that type exists and is a reference type;  If
T1
andT2
are both rvalue reference types: if the simple common reference type ofT1 &
andT2 &
(determined according to the previous bullet) exists, then letC
denote that type's corresponding rvalue reference type. If std::is_convertible<T1, C>::value and std::is_convertible<T2, C>::value are bothtrue
, then the simple common reference type ofT1
andT2
isC
.  Otherwise, one of the two types must be an lvalue reference type
A &
and the other must be an rvalue reference typeB &&
(A
andB
might be cvqualified). LetD
denote the simple common reference type of A & and B const &, if any. If D exists and std::is_convertible<B &&, D>::value istrue
, then the simple common reference type isD
.  Otherwise, there's no simple common reference type.
Contents 
[edit] Member types
Name  Definition 
type

the common reference type for all T...

[edit] Helper types
template< class... T > using common_reference_t = typename common_reference<T...>::type; 

template< class T, class U, template<class> class TQual, template<class> class UQual > struct basic_common_reference { }; 

The class template basic_common_reference
is a customization point that allows users to influence the result of common_reference
for userdefined types (typically proxy references). The primary template is empty.
[edit] Specializations
A program may specialize basic_common_reference<T, U, TQual, UQual>
on the first two parameters T
and U
if std::is_same<T, std::decay_t<T>> and std::is_same<U, std::decay_t<U>> are both true and at least one of them depends on a programdefined type.
If such a specialization has a member named type
, it must be a public and unambiguous member type that names a type to which both TQual<T> and UQual<U> are convertible. Additionally, ranges::basic_common_reference<T, U, TQual, UQual>::type and ranges::basic_common_reference<T, U, TQual, UQual>::type must denote the same type.
A program may not specialize basic_common_reference
on the third or fourth parameters, nor may it specialize common_reference
itself. A program that adds specializations in violation of these rules has undefined behavior.
[edit] Notes
This section is incomplete 
[edit] Examples
This section is incomplete Reason: no example 
[edit] See also
(C++11) 
determines the common type of a group of types (class template) 
determine the common type of a set of types (class template)  
specifies that two types share a common reference type (concept) 