Lvalue/rvalue -nes codant pour des références universelles

Question

J'ai lu moderne et efficace C++ et la chose suivante a attiré mon attention:

Dans l'article 28 Scott écrit:

Ensemble, ces observations sur universel références et encodage lvalue/rvalue signifient que pour ce modèle

template<typename T> void func(T&& param);

le paramètre T modèle déduit sera en code si l'argument passé à param était une lvalue ou un rvalue. Le mécanisme de codage est simple. Lorsqu'une valeur lvalue est passée en argument, T est déduite pour être une référence lvalue. Quand un rvalue est passé, T est déduit pour être une non-référence. (Note de l'asymétrie: lvalues ​​sont codées comme références lvalue, mais rvalues ​​sont codés comme non-références.)

Quelqu'un peut-il expliquer pourquoi un tel mécanisme de codage a été choisi? Je veux dire que si nous allons suivre les règles de réduction de référence que l'utilisation du modèle ci-dessus avec rvalue donne la référence rvalue. Et pour autant que je sache, tout fonctionnerait exactement de la même façon s'il était déduit comme référence. Pourquoi est-il codé comme non-référence?

Answer 1

Disons que vous devez passer param autour. En fait, vous devez le stocker à des fins de vie. Comme il est, vous souhaitez simplement utiliser T:

template <typename T> 
struct store { T val; }; 

template<typename T> void func(T&& param) { 
    store<T> s{std::forward<T>(param)}; 
} 

Cela fonctionne parce que si param suis fait passer par dans lvalue, T serait un type de référence lvalue, et nous vous copiez simplement la référence. Si param a été passé par rvalue, nous devons prendre la propriété - T est un type de non-référence, donc nous finissons par construire-déplacer en s.

Le fait que je peux utiliser T ici comme argument de modèle pour store, au lieu de std::conditional_t<std::is_lvalue_reference<T>::value, T, std::remove_reference_t<T>> est probablement pas un accident.

Answer 2

Je pense que vous pensez à tort. Au lieu de demander "pourquoi ne pas toujours faire T un type de référence", regardez-le de l'autre côté:

Supposons que vous ayez template <typename T> void f(T&&t).

Appelé comme int i; f(i);, certains T est nécessaire de sorte que T&& résout à int&. Quel est le plus simple T qui peut atteindre cet objectif? C'est int&.

Appelé comme f(0);, certains T est nécessaire de sorte que T&& résout à int&&. Quel est le plus simple T qui peut atteindre cet objectif? C'est int, pas int&&.

int&& n'a tout simplement aucun avantage ici.