std::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):
  • Let type S be the simple common reference type of T1 and T2 (as defined below). The member type type names S if all of the conditions below are satisfied:
    • T1 and T2 are both reference types
    • S is well-formed

• Otherwise, if std:: basic_common_reference < std::remove_cvref_t <T1>, std::remove_cvref_t <T2>, T1Q, T2Q> :: type exists, where TiQ is a unary alias template such that TiQ<U> is U with the addition of Ti's cv- and reference qualifiers, then the member type type

• • Otherwise, if decltype( false ? val<T1> ( ) : val<T2> ( ) ) , where val is a function template template < class T> T val( ) ; , is a valid type, then the member type type
  • Otherwise, if std::common_type_t<T1, T2> is a valid type, then the member type 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 std::common_reference_t<T1, T2> exists, the member type denotes std:: common_reference_t <std:: 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 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_v<T1, C> and std::is_convertible_v<T2, C> 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_v<B&&, D> is true, then the simple common reference type is D
• Otherwise, there's no simple common reference type.

See Conditional operator for the definition of the type of expression false ? X : Y

Member types

Helper types

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 std::basic_common_reference<T, U, TQual, UQual> on the first two parameters T and U if std::is_same_v <T, std::decay_t <T>> and std::is_same_v <U, std::decay_t <U>> are both true

If such a specialization has a member named type, it must be a public and unambiguous member that names a type to which both TQual<T> and UQual<U> are convertible. Additionally, std:: basic_common_reference <T, U, TQual, UQual> :: type and std:: basic_common_reference <U, T, UQual, TQual> :: type

A program may not specialize basic_common_reference on the third or fourth parameters, nor may it specialize common_reference

The standard library provides following specializations of basic_common_reference:

Notes

Examples

#include <concepts>
#include <type_traits>
 
static_assert(
    std::same_as<
        int&,
        std::common_reference_t<
            std::add_lvalue_reference_t<int>,
            std::add_lvalue_reference_t<int>&,
            std::add_lvalue_reference_t<int>&&,
            std::add_lvalue_reference_t<int>const,
            std::add_lvalue_reference_t<int>const&
        >
    >
);
 
int main() {}

See also