std:: unwrap_reference, std:: unwrap_ref_decay

From cppreference.com

Function wrappers
function (C++11)
move_only_function (C++23)
copyable_function (C++26)
function_ref (C++26)
mem_fn (C++11)
bad_function_call (C++11)

Partial function application
bind_front bind_back (C++20) (C++23)
bind (C++11)
is_bind_expression (C++11)
is_placeholder (C++11)
_1, _2, _3, ... (C++11)

Function invocation
invoke invoke_r (C++17) (C++23)
Identity function object
identity (C++20)

Reference wrappers
reference_wrapper (C++11)
ref cref (C++11) (C++11)
unwrap_reference unwrap_ref_decay (C++20) (C++20)

Operator wrappers

plus
minus
negate
multiplies
divides
modulus
bit_and
bit_or
bit_not (C++14)
bit_xor

equal_to
not_equal_to
greater
less
greater_equal
less_equal
logical_and
logical_or
logical_not

Transparent operator wrappers

plus <> (C++14)
minus <> (C++14)
negate <> (C++14)
multiplies <> (C++14)
divides <> (C++14)
modulus <> (C++14)
bit_and <> (C++14)
bit_or <> (C++14)
bit_not <> (C++14)
bit_xor <> (C++14)

equal_to <> (C++14)
not_equal_to <> (C++14)
greater <> (C++14)
less <> (C++14)
greater_equal <> (C++14)
less_equal <> (C++14)
logical_and <> (C++14)
logical_or <> (C++14)
logical_not <> (C++14)

Negators
not_fn (C++17)
Searchers
default_searcher (C++17)
boyer_moore_searcher (C++17)
boyer_moore_horspool_searcher (C++17)

Constrained comparators
ranges::equal_to (C++20)
ranges::not_equal_to (C++20)
ranges::greater (C++20)
ranges::less (C++20)
ranges::greater_equal (C++20)
ranges::less_equal (C++20)
compare_three_way (C++20)

Old binders and adaptors

unary_function ( until C++17* )
binary_function ( until C++17* )
ptr_fun ( until C++17* )
pointer_to_unary_function ( until C++17* )
pointer_to_binary_function ( until C++17* )
mem_fun ( until C++17* )
mem_fun_t mem_fun1_t const_mem_fun_t const_mem_fun1_t ( until C++17* ) ( until C++17* ) ( until C++17* ) ( until C++17* )
not1 ( until C++20* )
not2 ( until C++20* )

binder1st binder2nd ( until C++17* ) ( until C++17* )
bind1st bind2nd ( until C++17* ) ( until C++17* )

mem_fun_ref ( until C++17* )
mem_fun_ref_t mem_fun1_ref_t const_mem_fun_ref_t const_mem_fun1_ref_t ( until C++17* ) ( until C++17* ) ( until C++17* ) ( until C++17* )
unary_negate ( until C++20* )
binary_negate ( until C++20* )

Defined in header `<type_traits>`
Defined in header `<functional>`
template < class T > struct unwrap_reference ;	(1)	(since C++20)
template < class T > struct unwrap_ref_decay ;	(2)	(since C++20)

Unwraps any std::reference_wrapper : changing std:: reference_wrapper < U > to U& .

1) If

is a specialization of std::reference_wrapper , unwraps it; otherwise,

remains the same.

2) If the decayed

is a specialization of std::reference_wrapper , unwraps it; otherwise,

is decayed.

If the program adds specializations for any of the templates described on this page, the behavior is undefined.

Nested types

Type	Definition
`type`	(1) `U&` if `T` is std:: reference_wrapper < U > ; `T` otherwise (2) `U&` if std:: decay_t < T > is std:: reference_wrapper < U > ; std:: decay_t < T > otherwise

Helper types

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

Possible implementation

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>> {};

Notes

std::unwrap_ref_decay performs the same transformation as used by std::make_pair and std::make_tuple .

Feature-test macro	Value	Std	Feature
`__cpp_lib_unwrap_ref`	201811L	(C++20)	`std::unwrap_ref_decay` and `std::unwrap_reference`

Example

Run this code

#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; // Error: does not work if T is reference_wrapper<>
            // converts T&& into T& for ordinary types
            // converts T&& into U& for reference_wrapper<U>
            decltype(auto) r = std::unwrap_reference_t<T>(z);
            std::cout << "r: " << r << '\n';
            r = 0; // OK, r has reference type
        };
 
        int x = 1;
        reset(x);
        assert(x == 0);
 
        int y = 2;
        reset(std::ref(y));
        assert(y == 0);
    }
}

Output:

r: 1
r: 2

Compiler support
Freestanding and hosted
Language
Standard library
Standard library headers
Named requirements
Feature test macros (C++20)
Language support library
Concepts library (C++20)
Metaprogramming library (C++11)
Diagnostics library
General utilities library
Strings library
Containers library
Iterators library
Ranges library (C++20)
Algorithms library
Numerics library
Localizations library
Input/output library
Filesystem library (C++17)
Regular expressions library (C++11)
Concurrency support library (C++11)
Execution support library (C++26)
Technical specifications
Symbols index
External libraries

reference_wrapper (C++11)	CopyConstructible and CopyAssignable reference wrapper (class template)
make_pair	creates a `pair` object of type, determined by the argument types (function template)
make_tuple (C++11)	creates a `tuple` object of the type defined by the argument types (function template)