Namespaces
Variants

    std::basic_common_reference<std::reference_wrapper>

    Von de.cppreference.net
     
    C++
     
    Bibliothek für Hilfsmittel
    Sprachunterstützung
    Typunterstützung (Basistypen, RTTI)
    Feature-Test-Makros der Bibliothek (C++20)
    Programm-Hilfsmittel
    Variadische Funktionen
    (C++11)
    (C++20)
    (C++26)
    (C++20)
    Koroutinen-Unterstützung (C++20)
    Vertragsunterstützung (C++26)
    Drei-Wege-Vergleich
    (C++20)(C++20)
    (C++20)
    (C++20)
    (C++20)
    (C++20)
    (C++20)
    (C++20)
    (C++20)
    (C++20)
    (C++20)
    (C++20)
    (C++20)
    (C++20)    
    (C++20)(C++20)(C++20)    
    (C++20)(C++20)(C++20)

    Allgemeine Hilfsmittel
    Relationsoperatoren (veraltet in C++20)
    Ganzzahl-Vergleichsfunktionen
    (C++20)(C++20)(C++20)    
    (C++20)
    Swap und Typoperationen
    (C++20)
    (C++14)
    (C++11)
    (C++23)
    (C++11)
    (C++23)
    (C++11)
    (C++11)
    (C++17)
    Allgemeine Vokabelltypen
    (C++11)
    (C++17)
    (C++17)
    (C++17)
    (C++11)
    (C++11)
    (C++17)
    (C++17)
    (C++23)



     
    Funktionsobjekte
    Funktionsaufruf
    (C++17)(C++23)
    Identitäts-Funktionsobjekt
    (C++20)
    Transparente Operator-Wrapper
    (C++14)
    (C++14)
    (C++14)
    (C++14)  
    (C++14)
    (C++14)
    (C++14)
    (C++14)
    (C++14)
    (C++14)
    (C++14)
    (C++14)
    (C++14)
    (C++14)
    (C++14)
    (C++14)
    (C++14)
    (C++14)
    (C++14)

    Alte Binder und Adaptoren
    (bis C++17*)
    (bis C++17*)
    (bis C++17*)
    (bis C++17*)
    (bis C++17*)  
    (bis C++17*)
    (bis C++17*)(bis C++17*)(bis C++17*)(bis C++17*)
    (bis C++20*)
    (bis C++20*)
    (bis C++17*)(bis C++17*)
    (bis C++17*)(bis C++17*)

    (bis C++17*)
    (bis C++17*)(bis C++17*)(bis C++17*)(bis C++17*)
    (bis C++20*)
    (bis C++20*)
     
    std::reference_wrapper
     
    Definiert in Header <functional> 
    template< class R, class T,
          template<class> RQual, template<class> TQual >
    requires (/*ref-wrap-common-reference-exists-with*/<R, T, RQual<R>, TQual<T>> &&
              !/*ref-wrap-common-reference-exists-with*/<T, R, TQual<T>, RQual<R>>)
struct basic_common_reference<R, T, RQual, TQual>;
    		(1) (seit C++23) 
    template< class T, class R,
          template<class> TQual, template<class> RQual >
    requires (/*ref-wrap-common-reference-exists-with*/<R, T, RQual<R>, TQual<T>> &&
              !/*ref-wrap-common-reference-exists-with*/<T, R, TQual<T>, RQual<R>>)
struct basic_common_reference<T, R, TQual, RQual>;
    		(2) (seit C++23)
    Helfer-Concepts
    		 
    template< class R, class T, class RQ, class TQ >
concept /*ref-wrap-common-reference-exists-with*/ =
    /*is-ref-wrapper*/<R> &&
    requires { typename std::common_reference_t<typename R::type&, TQ>; } &&
    std::convertible<RQ, std::common_reference_t<typename R::type&, TQ>>;
    		(3) (nur zur Darstellung*)

    Der gemeinsame Referenztyp eines reference_wrapper (bezeichnet als R) und eines Typs T, entsprechend mit cv- und Referenz-Qualifizierern versehen (bezeichnet als RQ bzw. TQ), ist äquivalent zu einem gemeinsamen Referenztyp des zugrundeliegenden Typs von R, versehen mit lvalue-Referenz, und dem TQ.

    Der gemeinsame Referenztyp ist nur definiert, wenn R der einzige reference_wrapper ist, der zugrundeliegende Typ von R versehen mit lvalue-Referenz und der TQ einen gemeinsamen Referenztyp haben, in den RQ konvertierbar sein muss.

    Die nur zur Darstellung dienende Konstante /*is-ref-wrapper*/<R> ist true genau dann, wenn R eine Spezialisierung von std::reference_wrapper ist.

    Mitgliedertypen

    Mitgliedstyp Definition
    type std:: common_reference_t < typename R :: type & , TQual < T >> ( 1,2 )

    Hinweise

    Feature-Test Makro Wert Std Funktion
    __cpp_lib_common_reference_wrapper 202302L (C++23) Mache std::common_reference_t von std::reference_wrapper zu einem Referenztyp

    Beispiel

    Diesen Code ausführen 
    #include <concepts>
#include <functional>
static_assert(std::same_as<std::common_reference_t<int&,
                                                   std::reference_wrapper<int>>,
                                                   int&>);
static_assert(std::same_as<std::common_reference_t<std::reference_wrapper<int>&,
                                                   int&>,
                                                   int&>);
static_assert(std::same_as<std::common_reference_t<int&,
                                                   const std::reference_wrapper<int>&>,
                                                   int&>);
int main() {}

    Siehe auch

    (C++20)
    		bestimmt den gemeinsamen Referenztyp einer Gruppe von Typen
    (Klassentemplate)