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

CKTIS / C++

Référence à une lvalue (`R&`)

`R&` est un alias d’un objet existant. Une affectation via la référence modifie cet objet. Un retour de type `R&` permet à l’appelant de continuer à accéder au même objet sans le copier.

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

Syntaxe

R& ref = target;
R& get();
const R& read_only = target;

template<class R, class F>
R& run_interval(R& result, F&& namedf, int first, int last);

Une référence à une lvalue R& est un alias d’un objet existant. Dans R& ref = target;, l’initialisation lie ref à target sans copie. Ici, & fait partie du déclarateur : ce n’est pas l’opérateur de prise d’adresse. Ensuite, ref = value; affecte une valeur à l’objet si l’affectation est valide ; la référence reste liée au même objet.

Un int& peut se lier à une variable ordinaire de type int, mais pas à un const int ni au littéral 42. Un const int& ne permet pas de modifier l’objet via cette référence. Il peut aussi se lier à un objet temporaire ; la prolongation de la durée de vie dépend du contexte de cette liaison.

Dans l’exemple, R& result est un alias de la variable de l’appelant. Pour chaque i dans [first, last), result = namedf(i); écrit dans cette même variable. La fonction renvoie R& : l’appel est donc une lvalue et auto& alias se lie au même objet. Un retour par valeur ne fournit pas cet alias.

Ici, F&& est une référence de transfert, car F est un paramètre de type déduit de ce modèle de fonction, sans qualification const ni volatile. L’expression namedf elle-même est une lvalue, même si le type du paramètre après déduction est une référence à une rvalue. Ainsi, namedf(i) invoque l’objet appelable en tant que lvalue. std::forward<F>(namedf) préserverait la distinction entre lvalue et rvalue, mais pas nécessairement la catégorie de valeur exacte : l’expression lambda passée en argument est une prvalue au site d’appel, tandis que std::forward<F>(namedf) produirait une xvalue. Un appel via cette expression pourrait sélectionner une autre surcharge de operator().

[&] capture par référence la variable locale base, utilisée par la lambda. La variable globale offset est accessible sans capture. Ni le retour d’une référence ni la capture par référence ne prolonge la durée de vie de ces variables locales. Ne renvoyez pas de référence à une variable locale dont la durée de vie se termine à la sortie de la fonction : lire via la référence pendante qui en résulte entraîne un comportement indéfini.

Exemples

#include <iostream>

int offset = 1;

template<class R, class F>
R& run_interval(R& result, F&& namedf, int first, int last)
{
    for (int i = first; i < last; ++i) {
        result = namedf(i);
    }
    return result;
}

int main()
{
    int result = 0;
    int base = 39;
    auto& alias = run_interval(result, [&](int i) {
        return base + offset + i;
    }, 0, 3);

    std::cout << result << '\n';
    alias = 43;
    std::cout << result << '\n';
}

Résultat

42
43

Pour `i` valant `0`, `1` puis `2`, la boucle écrit `40`, `41` puis `42`. Ensuite, `alias = 43` modifie la même variable `result` : la seconde ligne affiche donc `43`.

Leçons associées

  • C++ · Leçon 24 · Avancé · Version : 3

Sources