Base de connaissancesCentre d’examen
FRFrançais
Choisir la langue13

CKTIS / C++

Déclarateur de référence rvalue (`&&`)

Le déclarateur `&&` forme un type référence rvalue. La résolution de surcharge dépend pourtant de la catégorie de l’expression : le nom d’une variable déclarée `T&&` est une lvalue lorsqu’il sert d’argument.

Version : ISO C++23; implementation support may vary

Syntaxe

T&& ref = expr;               // local reference; requires a suitable initializer
void consume(T&& arg);        // reference parameter
T&& access();                 // reference return type; does not extend lifetime
using R = T&&;                // reference type alias; collapsing can apply
template<class U> void relay(U&& arg);  // forwarding reference when U is deduced

Dans T&& ref, si T est un type objet et non un type référence, && déclare une référence rvalue. T& est une référence lvalue ; dans const T&, const qualifie l’objet. Ce n’est ni le ET logique intégré a && b, qui n’évalue pas l’opérande droit si le gauche est faux, ni le ET bit à bit a & b, ni la prise d’adresse &x. Dans void f() &&, le symbole est un qualificateur de référence de la fonction membre. Les références rvalue existent depuis C++11 ; les règles présentées sont celles d’ISO C++23.

Une référence T&& ordinaire ne peut pas se lier directement à une lvalue du même type objet T. Elle peut se lier à une prvalue, ce qui matérialise un objet temporaire, ou à une xvalue comme std::move(x), qui peut désigner un objet existant. Comme argument d’appel, le nom ref est une lvalue même s’il est déclaré T&&. Avec les surcharges const int& et int&& de l’exemple, une rvalue de type int sélectionne int&& ; une lvalue de type int ou une xvalue de type const int sélectionne const int&.

Pour un objet, std::move, fourni par <utility>, produit une xvalue : il ne retire pas const et ne déplace rien lui-même. Task(Task&&) et Task& operator=(Task&&) sont des opérations de déplacement courantes ; dans la seconde, Task& est le type de retour. L’opération peut transférer la propriété d’une ressource, comme le cadre d’une coroutine, mais la liaison de la référence ne la transfère pas. Pour une opération de copie, = delete en interdit l’utilisation ; pour une opération de déplacement, = default demande l’implémentation prévue par le langage, qui peut néanmoins être supprimée.

La déclaration locale T&& ref = T{}; prolonge la durée de vie de ce temporaire jusqu’à la fin de vie de la référence. Un temporaire lié à un paramètre référence ne vit que jusqu’à la fin de l’expression complète qui contient l’appel. Transmettre la référence ne prolonge pas de nouveau cette durée. Ne renvoyez pas de référence à un objet local détruit à la sortie de la fonction.

Dans template<class U> void relay(U&& arg), U&& est une référence de transmission lorsque U est déduit. Pour une lvalue de type T, U est déduit comme T& et la combinaison des références donne T& ; pour une rvalue de type T, le résultat est T&&. Dans cette combinaison, la présence de & donne & ; seuls deux && donnent &&. Utilisez std::forward<U>(arg) de <utility> pour transmettre l’argument comme lvalue ou rvalue selon la déduction. const U&& n’est pas une référence de transmission.

Exemples

#include <iostream>
#include <utility>

void probe(const int&) { std::cout << "const int&\n"; }
void probe(int&&)      { std::cout << "int&&\n"; }

int main() {
    int value = 1;
    int&& ref = 2;
    const int frozen = 3;

    probe(value);
    probe(7);
    probe(ref);
    probe(std::move(ref));
    probe(std::move(frozen));
}

Résultat

const int&
int&&
const int&
int&&
const int&

Dans l’appel, `ref` est une lvalue, tandis que `std::move(ref)` est une xvalue et sélectionne `int&&`. `std::move(frozen)` conserve `const` et sélectionne donc `const int&`. Le programme montre la sélection de surcharge, pas un transfert de ressources.

Leçons associées

  • C++ · Leçon 11 · Avancé · Version : 3
  • C++ · Leçon 19 · Avancé · Version : 3
  • C++ · Leçon 41 · Avancé · Version : 3
  • C++ · Leçon 42 · Avancé · Version : 3
  • C++ · Leçon 43 · Avancé · Version : 3
  • C++ · Leçon 45 · Avancé · Version : 3

Sources