Namespaces
Variants

std:: add_lvalue_reference, std:: add_rvalue_reference

From cppreference.net
C++
Metaprogramming library
Type traits
Type categories
(C++11)
(C++11) ( DR* )
(C++11)
(C++11)
(C++11)
(C++11)
(C++11)
Type properties
(C++11)
(C++11)
(C++11)
(C++11)
(C++14)
(C++11)
(C++17)
(C++23)
(C++11) (deprecated in C++26)
(C++11)
(C++11)
(C++11) ( until C++20* )
(C++11) (deprecated in C++20)
(C++11)
(C++11)
(C++20)
(C++20)
(C++23)
(C++17)
Type trait constants
(C++11) (C++17) (C++11) (C++11)
Metafunctions
(C++17)
(C++17)
(C++17)
Supported operations
Relationships and property queries
Type modifications
(C++11)
add_lvalue_reference add_rvalue_reference
(C++11) (C++11)
(C++11)
(C++11)
(C++11)
(C++11)

Type transformations
(C++11) (deprecated in C++23)
(C++11) (deprecated in C++23)
(C++11)
(C++20)
(C++11) ( until C++20* ) (C++17)

Compile-time rational arithmetic
Compile-time integer sequences
(C++14)
Défini dans l'en-tête <type_traits>
template < class T >
struct add_lvalue_reference ;
(1) (depuis C++11)
template < class T >
struct add_rvalue_reference ;
(2) (depuis C++11)

Crée un type de référence lvalue ou rvalue de T .

Caractéristique de type Le type référencé par le type imbriqué type
T est un type référençable T n'est pas un type référençable
(1) T& [1] T
(2) T&& [2]
  1. ↑ Cette règle reflète la sémantique du reference collapsing .
  2. ↑ Cette règle reflète la sémantique du reference collapsing . Notez que std :: add_rvalue_reference < T & > :: type est T& , qui n'est pas un type de référence rvalue.

Si le programme ajoute des spécialisations pour l'un des modèles décrits sur cette page, le comportement est indéfini.

Table des matières

Types imbriqués

Nom Définition
type déterminé comme ci-dessus

Types auxiliaires

template < class T >
using add_lvalue_reference_t = typename add_lvalue_reference < T > :: type ;
(depuis C++14)
template < class T >
using add_rvalue_reference_t = typename add_rvalue_reference < T > :: type ;
(depuis C++14)

Notes

La principale différence avec l'utilisation directe de T& ou T&& est que T peut être un type non référençable . Par exemple, std :: add_lvalue_reference < void > :: type est void , tandis que void & provoque une erreur de compilation.

Implémentation possible 

namespace detail
{
    template<class T>
    struct type_identity { using type = T; }; // ou utilisez std::type_identity (depuis C++20)
    template<class T> // Notez que « cv void& » est un échec de substitution
    auto try_add_lvalue_reference(int) -> type_identity<T&>;
    template<class T> // Gère le cas T = cv void
    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)) {};

Exemple

Exécuter ce code 
#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() {}

Rapports de défauts

Les rapports de défauts modifiant le comportement suivants ont été appliqués rétroactivement aux normes C++ précédemment publiées.

DR Applicable à Comportement publié Comportement corrigé
LWG 2101 C++11 le programme était mal formé si T est un type fonction avec cv ou ref le type produit est T dans ce cas

Voir aussi

(C++11)
vérifie si un type est soit une référence lvalue soit une référence rvalue
(modèle de classe)
(C++11)
supprime une référence du type donné
(modèle de classe)
(C++20)
combine std::remove_cv et std::remove_reference
(modèle de classe)