CKTIS / C++
Référence rvalue : T&&
T&& déclare une référence rvalue, un type distinct de T&. Elle se lie aux rvalues appropriées et intervient dans la sémantique de déplacement. Le nom d'une référence utilisé comme expression est normalement une lvalue. En C++23, un nom éligible au déplacement implicite est toutefois une xvalue, par exemple lorsque le nom d'un paramètre de type référence rvalue vers un type objet non qualifié par volatile est directement l'opérande d'une instruction return. T&& avec un paramètre de modèle déduit peut être une référence de transfert.
Version : C++23; repository compiler flag, production runtime not attested
Syntaxe
T&& name = expression;
void consume(T&& value);
template<class T> void relay(T&& value);Pour un type objet T fixe et qui n'est pas une référence, T&& désigne une référence rvalue ; T& désigne le type distinct de référence lvalue. Par exemple, int&& r = 7; lie r à un objet temporaire. Un int&& ne peut pas se lier directement à une lvalue de type int. Une définition locale de référence doit être initialisée. Une affectation ultérieure modifie l'objet référencé, et non l'objet que désigne la référence.
Le type d'une déclaration et la catégorie de valeur d'une expression sont deux choses différentes. Dans l'exemple, r a le type déclaré int&&, mais l'expression r est une lvalue. Ainsi, inspect(r) sélectionne int&, tandis que inspect(std::move(r)) sélectionne int&&. std::move présente une expression comme une xvalue ; il ne transfère pas lui-même de ressources. Un constructeur ou opérateur d'affectation sélectionné ensuite peut effectuer un déplacement.
Tout T&& n'est pas un paramètre ordinaire réservé aux rvalues. Dans template<class T> void relay(T&& value);, lorsque T est déduit à partir de l'argument de l'appel, il s'agit d'une référence de transfert : elle accepte les lvalues et les rvalues. Pour un argument lvalue de type int, T est déduit comme int&, et la réduction des références produit int&. La règle est la suivante : seul && combiné à && donne && ; toutes les autres combinaisons donnent &. Un paramètre const T&& n'est pas une référence de transfert. Pour transmettre à son tour, utilisez std::forward<T>(value).
Une référence ne garantit pas que son objet existe encore. La liaison directe d'un temporaire dans int&& r = 7; prolonge sa durée de vie jusqu'à la fin de celle de la référence locale. Cependant, un temporaire lié à un paramètre référence ne vit que jusqu'à la fin de l'expression complète contenant l'appel. Conserver cette référence ne prolonge pas à nouveau la durée de vie de l'objet et peut laisser une référence pendante.
Exemples
#include <iostream>
#include <utility>
void inspect(int&) {
std::cout << "lvalue\n";
}
void inspect(int&&) {
std::cout << "rvalue\n";
}
int main() {
int&& r = 7;
inspect(r);
inspect(std::move(r));
inspect(9);
r = 12;
std::cout << r << '\n';
}
Résultat
lvalue rvalue rvalue 12
Le code affiché et le résultat déclaré ont été vérifiés dans un environnement isolé selon la méthode consignée dans la preuve de vérification de cette version exacte.