std:: add_lvalue_reference, std:: add_rvalue_reference

Creates an lvalue or rvalue reference type of T .

1. ↑ This rule reflects the semantics of reference collapsing .
2. ↑ This rule reflects the semantics of reference collapsing . Note that std :: add_rvalue_reference < T & > :: type is T& , which is not an rvalue reference type.

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

Nested types

Helper types

Notes

The major difference to directly using T& or T&& is that T can be a non- referenceable type. For example, std :: add_lvalue_reference < void > :: type is void , while void & leads to a compilation error.

Possible implementation

namespace detail
{
    template<class T>
    struct type_identity { using type = T; }; // or use std::type_identity (since C++20)
 
    template<class T> // Note that “cv void&” is a substitution failure
    auto try_add_lvalue_reference(int) -> type_identity<T&>;
    template<class T> // Handle T = cv void case
    auto try_add_lvalue_reference(...) -> type_identity<T>;
 
    template<class T>
    auto try_add_rvalue_reference(int) -> type_identity<T&&>;
    template<class T>
    auto try_add_rvalue_reference(...) -> type_identity<T>;
} // namespace detail
 
template<class T>
struct add_lvalue_reference
    : decltype(detail::try_add_lvalue_reference<T>(0)) {};
 
template<class T>
struct add_rvalue_reference
    : decltype(detail::try_add_rvalue_reference<T>(0)) {};

Example

#include <type_traits>
 
using non_ref = int;
static_assert(std::is_lvalue_reference_v<non_ref> == false);
 
using l_ref = std::add_lvalue_reference_t<non_ref>;
static_assert(std::is_lvalue_reference_v<l_ref> == true);
 
using r_ref = std::add_rvalue_reference_t<non_ref>;
static_assert(std::is_rvalue_reference_v<r_ref> == true);
 
using void_ref = std::add_lvalue_reference_t<void>;
static_assert(std::is_reference_v<void_ref> == false);
 
int main() {}

Defect reports

The following behavior-changing defect reports were applied retroactively to previously published C++ standards.

See also