CKTIS / C++
Riferimento a lvalue (`R&`)
`R&` è un alias di un oggetto esistente. Un’assegnazione tramite il riferimento modifica quell’oggetto. Restituire `R&` consente al chiamante di continuare ad accedere allo stesso oggetto senza copiarlo.
Versione: ISO C++23; implementation support may vary
Sintassi
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);Un riferimento a lvalue R& è un alias di un oggetto esistente. In R& ref = target;, l’inizializzazione lega ref a target senza copiarlo. Qui & fa parte del dichiaratore e non è l’operatore che prende l’indirizzo. Una successiva istruzione ref = value; assegna un valore all’oggetto, se l’assegnazione è valida; il legame non cambia.
Un int& può legarsi a una normale variabile di tipo int, ma non a un const int né al letterale 42. Un const int& non consente di modificare l’oggetto tramite quel riferimento. Può anche legarsi a un oggetto temporaneo; l’eventuale estensione della durata di vita dipende dal contesto del legame.
Nell’esempio, R& result è un alias della variabile del chiamante. Per ogni i in [first, last), result = namedf(i); scrive nella stessa variabile. La funzione restituisce R&, quindi la chiamata è un lvalue e auto& alias si lega allo stesso oggetto. Restituire per valore non fornisce questo alias.
Qui F&& è un riferimento di inoltro perché F è un parametro di tipo dedotto di questo template di funzione, senza qualificatori const o volatile. L’espressione namedf è un lvalue, anche se dopo la deduzione il tipo del parametro è un riferimento a rvalue. namedf(i) invoca quindi l’oggetto chiamabile come lvalue. std::forward<F>(namedf) manterrebbe la distinzione tra lvalue e rvalue, ma non necessariamente la categoria di valore esatta: l’espressione lambda passata come argomento è un prvalue nel punto della chiamata, mentre std::forward<F>(namedf) produrrebbe un xvalue. Una chiamata tramite quell’espressione potrebbe selezionare un altro overload di operator().
[&] cattura per riferimento la variabile locale base, usata dalla lambda. La variabile globale offset è accessibile senza cattura. Né restituire un riferimento né catturare per riferimento prolunga la durata di vita di queste variabili locali. Non restituire un riferimento a una variabile locale la cui vita termina all’uscita dalla funzione: leggere tramite il riferimento pendente che ne risulta ha comportamento indefinito.
Esempi
#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';
}
Risultato
42 43
Per `i` uguale a `0`, `1` e `2`, il ciclo scrive `40`, `41` e `42`. Poi `alias = 43` modifica la stessa variabile `result`, quindi la seconda riga mostra `43`.
Lezioni correlate
- C++ · Lezione 24 · Avanzato · Versione: 3