NAME¶

std::experimental::ranges::common_reference - std::experimental::ranges::common_reference

Synopsis¶

Defined in header <experimental/ranges/type_traits>
template< class... T > (ranges TS)
struct common_reference;

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 cv-qualified) 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 non-reference
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 type T0), the member type
names the same type as T0.
* If sizeof...(T) is two (i.e., T... contains two types T1 and T2):

* If T1 and T2 are both reference types, and the simple common reference type
S of T1 and T2 (as defined below) exists, then the member type type names
S;
* Otherwise, if basic_common_reference<T1R, T2R, T1Q, T2Q>::type exists,
where TiR is std::remove_cv_t<std::remove_reference_t<Ti>> and TiQ is an
alias template such that TiQ<TiR> is Ti, then the member type type 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 type type 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 sizeof...(T) is greater than two (i.e., T... consists of the types T1, T2,
R...), then if ranges::common_reference_t<T1, T2> exists, the member type
denotes ranges::common_reference_t<ranges::common_reference_t<T1, T2>, R...> if
such a type exists. In all other cases, there is no member type.

The simple common reference type of two reference types T1 and T2 is defined as
follows:

* If T1 is cv1 X & and T2 is cv2 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 and T2 are both rvalue reference types: if the simple common reference
type of T1 & and T2 & (determined according to the previous bullet) exists, then
let C denote that type's corresponding rvalue reference type. If
std::is_convertible<T1, C>::value and std::is_convertible<T2, C>::value are both
true, then the simple common reference type of T1 and T2 is C.
* Otherwise, one of the two types must be an lvalue reference type A & and the
other must be an rvalue reference type B && (A and B might be cv-qualified). Let
D denote the simple common reference type of A & and B const &, if any. If D
exists and std::is_convertible<B &&, D>::value is true, then the simple common
reference type is D.
* Otherwise, there's no simple common reference type.

Member types¶

Name Definition
type the common reference type for all T...

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 user-defined types (typically proxy
references). The primary template is empty.

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 program-defined
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<U, T, UQual, TQual>::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.

Notes¶

This section is incomplete

Examples¶

This section is incomplete
Reason: no example

See also¶

common_type determines the common type of a group of types
(C++11) (class template)
common_type determine the common type of a set of types
(class template)
CommonReference specifies that two types share a common reference type
(concept)