Namespaces
Variants

    std::unwrap_reference, std::unwrap_ref_decay

    Von de.cppreference.net
     
    C++
     
    Dienstprogrammbibliothek
    Sprachunterstützung
    Typunterstützung (Basistypen, RTTI)
    Bibliotheks-Feature-Test-Makros (C++20)
    Programmdienstprogramme
    Variadische Funktionen
    (C++11)
    (C++20)
    (C++26)
    (C++20)
    Koroutinenunterstü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 Dienstprogramme
    Relationsoperatoren (veraltet in C++20)
    Ganzzahlvergleichsfunktionen
    (C++20)(C++20)(C++20)    
    (C++20)
    Tausch und Typoperationen
    (C++20)
    (C++14)
    (C++11)
    (C++23)
    (C++11)
    (C++23)
    (C++11)
    (C++11)
    (C++17)
    Allgemeine Vokabular-Typen
    (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ätsfunktionsobjekt
    (C++20)
    Transparente Operatorwrapper
    (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*)
     
    Definiert in Header <type_traits>
    Definiert in Header <functional> 
    template< class T >
struct unwrap_reference;
    		(1) (seit C++20) 
    template< class T >
struct unwrap_ref_decay;
    		(2) (seit C++20)

    Entfernt die Hülle eines std::reference_wrapper: ändert std::reference_wrapper<U> zu U&.

    1) Falls T eine Spezialisierung von std::reference_wrapper ist, wird die Hülle entfernt; andernfalls bleibt T unverändert.
    2) Falls der zerfallene Typ T eine Spezialisierung von std::reference_wrapper ist, wird die Hülle entfernt; andernfalls wird T zerfallen.

    Wenn das Programm Spezialisierungen für eine der auf dieser Seite beschriebenen Vorlagen hinzufügt, ist das Verhalten undefiniert.

    Verschachtelte Typen

    Typ Definition
    type

    (1) U& falls T ein std:: reference_wrapper < U > ist; T sonst
    (2) U& falls std:: decay_t < T > ein std:: reference_wrapper < U > ist; std:: decay_t < T > sonst

    Hilfstypen

    template < class T >
    using unwrap_reference_t = unwrap_reference < T > :: type ;
    		(1) (seit C++20)
    template < class T >
    using unwrap_ref_decay_t = unwrap_ref_decay < T > :: type ;
    		(2) (seit C++20)

    Mögliche Implementierung 

    template<class T>
struct unwrap_reference { using type = T; };
template<class U>
struct unwrap_reference<std::reference_wrapper<U>> { using type = U&; };
template<class T>
struct unwrap_ref_decay : std::unwrap_reference<std::decay_t<T>> {};

    Hinweise

    std::unwrap_ref_decay führt dieselbe Transformation durch, die auch von std::make_pair und std::make_tuple verwendet wird.

    Feature-Test Makro Wert Std Feature
    __cpp_lib_unwrap_ref 201811L (C++20) std::unwrap_ref_decay und std::unwrap_reference

    Beispiel

    Diesen Code ausführen 
    #include <cassert>
#include <functional>
#include <iostream>
#include <type_traits>
int main()
{
    static_assert(std::is_same_v<std::unwrap_reference_t<int>, int>);
    static_assert(std::is_same_v<std::unwrap_reference_t<const int>, const int>);
    static_assert(std::is_same_v<std::unwrap_reference_t<int&>, int&>);
    static_assert(std::is_same_v<std::unwrap_reference_t<int&&>, int&&>);
    static_assert(std::is_same_v<std::unwrap_reference_t<int*>, int*>);
    {
        using T = std::reference_wrapper<int>;
        using X = std::unwrap_reference_t<T>;
        static_assert(std::is_same_v<X, int&>);
    }
    {
        using T = std::reference_wrapper<int&>;
        using X = std::unwrap_reference_t<T>;
        static_assert(std::is_same_v<X, int&>);
    }
    static_assert(std::is_same_v<std::unwrap_ref_decay_t<int>, int>);
    static_assert(std::is_same_v<std::unwrap_ref_decay_t<const int>, int>);
    static_assert(std::is_same_v<std::unwrap_ref_decay_t<const int&>, int>);
    {
        using T = std::reference_wrapper<int&&>;
        using X = std::unwrap_ref_decay_t<T>;
        static_assert(std::is_same_v<X, int&>);
    }
    {
        auto reset = []<typename T>(T&& z)
        {
        //  x = 0; // Fehler: funktioniert nicht, wenn T ein reference_wrapper<> ist
            // konvertiert T&& in T& für gewöhnliche Typen
            // konvertiert T&& in U& für reference_wrapper<U>
            decltype(auto) r = std::unwrap_reference_t<T>(z);
            std::cout << "r: " << r << '\n';
            r = 0; // OK, r hat Referenztyp
        };
        int x = 1;
        reset(x);
        assert(x == 0);
        int y = 2;
        reset(std::ref(y));
        assert(y == 0);
    }
}

    Ausgabe: 

    r: 1
r: 2

    Siehe auch

    (C++11)
    		CopyConstructible und CopyAssignable Referenz-Wrapper
    (Klassen-Template)
    		erstellt ein pair -Objekt vom Typ, bestimmt durch die Argumenttypen
    (Funktions-Template)
    (C++11)
    		erstellt ein tuple -Objekt des durch die Argumenttypen definierten Typs
    (Funktions-Template)