CKTIS / C++
Lvalue-referentie (`R&`)
`R&` is een alias voor een bestaand object. Een toewijzing via de referentie wijzigt dat object. Met `R&` als retourtype kan de aanroeper hetzelfde object blijven gebruiken zonder het te kopiëren.
Versie: ISO C++23; implementation support may vary
Syntax
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);Een lvalue-referentie R& is een alias voor een bestaand object. In R& ref = target; bindt de initialisatie ref aan target zonder kopie. & is hier deel van de declarator, niet de adresoperator. Een latere ref = value; wijst een waarde toe aan het object als die toewijzing geldig is; de referentie blijft aan hetzelfde object gebonden.
Een int& kan worden gebonden aan een gewone int-variabele, maar niet aan een const int of de letterlijke waarde 42. Via een const int& kun je het object niet wijzigen. Zo'n referentie kan ook aan een tijdelijk object worden gebonden; of de levensduur wordt verlengd, hangt af van de bindingscontext.
In het voorbeeld is R& result een alias voor de variabele van de aanroeper. Voor elke i in [first, last) schrijft result = namedf(i); naar diezelfde variabele. De functie retourneert R&, dus de aanroep is een lvalue en auto& alias bindt aan hetzelfde object. Retourneren op waarde levert die alias niet op.
F&& is hier een forwarding reference omdat F een afgeleide typeparameter van deze functietemplate is zonder const- of volatile-kwalificatie. De expressie namedf zelf is een lvalue, zelfs als de parameter na typeafleiding een rvalue-referentie is. namedf(i) roept het aanroepbare object dus aan als lvalue. std::forward<F>(namedf) zou het onderscheid tussen lvalue en rvalue behouden, maar niet noodzakelijk de exacte waardecategorie: de lambda-expressie die als argument wordt meegegeven, is op de aanroepplek een prvalue, terwijl std::forward<F>(namedf) een xvalue zou opleveren. Een aanroep via die expressie zou een andere overload van operator() kunnen selecteren.
[&] legt de gebruikte lokale variabele base vast per referentie. De globale variabele offset is toegankelijk zonder capture. Noch het retourneren van een referentie, noch het vastleggen per referentie verlengt de levensduur van deze lokale variabelen. Retourneer geen referentie naar een lokale variabele waarvan de levensduur eindigt als de functie terugkeert: lezen via de resulterende ongeldige referentie leidt tot ongedefinieerd gedrag.
Voorbeelden
#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';
}
Resultaat
42 43
Voor `i` gelijk aan `0`, `1` en `2` schrijft de lus `40`, `41` en `42`. Daarna wijzigt `alias = 43` dezelfde variabele `result`, dus de tweede regel toont `43`.
Gerelateerde lessen
- C++ · Les 24 · Gevorderd · Versie: 3