CKTIS / C++
La référence de transmission `F&&`
Lorsque `F` est déduit, `F&&` peut se lier à une lvalue ou à une rvalue. `f()` traite l’objet appelable comme une lvalue ; `std::forward<F>(f)` le transmet comme lvalue ou rvalue selon l’argument.
Version : ISO C++23; implementation support may vary
Syntaxe
#include <utility>
template<class F>
void call(F&& f) {
std::forward<F>(f)();
}Dans template<class F> void call(F&& f), f est une référence de transmission : && s’applique directement au paramètre de type F, sans ajout de const ni de volatile, et F est déduit à l’appel. Pour une lvalue de type T, on déduit F = T& et les règles de repli des références donnent à f le type T&. Pour une rvalue de type T, on déduit F = T et f est de type T&&. Les qualificatifs du type de l’argument, tels que const, sont conservés.
La seule présence de && ne suffit pas. Ni const F&&, ni un type concret comme Callable&&, ni F&& lorsque F est déjà fixé par une spécialisation de modèle de classe ne sont des références de transmission.
Dans f(), l’expression f est une lvalue, même si le type déclaré du paramètre est Callable&&. std::forward<F>(f), fourni par <utility>, utilise le F déduit : pour les objets, il produit une lvalue pour un argument lvalue, et une xvalue (une sorte de rvalue) pour un argument rvalue. Cela peut changer la surcharge sélectionnée : operator()() & ou operator()() &&.
std::forward ne copie ni ne déplace lui-même l’objet et ne prolonge pas sa durée de vie. Un objet temporaire lié à un paramètre référence subsiste jusqu’à la fin de l’expression complète qui contient l’appel. Toute référence conservée vers cet objet devient ensuite pendante.
Exemples
#include <iostream>
#include <utility>
struct Callable {
const char* operator()() & { return "lvalue"; }
const char* operator()() && { return "rvalue"; }
};
template<class F>
void compare(F&& f) {
const char* direct = f();
const char* forwarded = std::forward<F>(f)();
std::cout << direct << ' ' << forwarded << '\n';
}
int main() {
Callable callable;
compare(callable);
compare(Callable{});
}Résultat
lvalue lvalue lvalue rvalue
Chaque ligne montre d’abord le résultat de `f()`, puis celui de `std::forward<F>(f)()`. Pour `callable`, les deux appels sélectionnent `&` ; pour `Callable{}`, le premier sélectionne `&` et le second `&&`. L’objet n’est appelé deux fois que pour comparer les surcharges.
Leçons associées
- C++ · Leçon 24 · Avancé · Version : 3