KennisbankExamencentrum
NL · NLNederlands (Nederland)
Taal kiezen13

CKTIS / C++

De doorgeefreferentie `F&&`

Als `F` wordt afgeleid, kan `F&&` zowel aan een lvalue als aan een rvalue binden. `f()` behandelt het aanroepbare object als lvalue; `std::forward<F>(f)` geeft het door als lvalue of rvalue, afhankelijk van het argument.

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

Syntax

#include <utility>

template<class F>
void call(F&& f) {
    std::forward<F>(f)();
}

In template<class F> void call(F&& f) is f een doorgeefreferentie: && staat direct bij typeparameter F, zonder toegevoegd const of volatile, en F wordt bij de aanroep afgeleid. Voor een lvalue van type T volgt F = T&; door het samenvoegen van referenties krijgt f type T&. Voor een rvalue van type T volgt F = T, dus krijgt f type T&&. Kwalificaties van het argumenttype, zoals const, blijven behouden.

De notatie && alleen is niet genoeg. const F&&, een concreet type zoals Callable&& en F&& waarbij F al vastligt door een specialisatie van de klassetemplate, zijn geen doorgeefreferenties.

In f() is de expressie f een lvalue, zelfs als het gedeclareerde parametertype Callable&& is. std::forward<F>(f) uit <utility> gebruikt het afgeleide F: bij objecten levert een lvalue-argument een lvalue op, en een rvalue-argument een xvalue (een soort rvalue). Daardoor kan de gekozen overload verschillen: operator()() & of operator()() &&.

std::forward zelf kopieert of verplaatst het object niet en verlengt de levensduur ervan niet. Een tijdelijk object dat aan een referentieparameter is gebonden, blijft bestaan tot het einde van de volledige expressie die de aanroep bevat. Een bewaarde referentie naar dat object verwijst daarna naar een object dat niet meer bestaat.

Voorbeelden

#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{});
}

Resultaat

lvalue lvalue
lvalue rvalue

Elke regel toont eerst het resultaat van `f()` en daarna dat van `std::forward<F>(f)()`. Voor `callable` kiezen beide aanroepen `&`; voor `Callable{}` kiest de eerste `&` en de tweede `&&`. Het object wordt alleen tweemaal aangeroepen om de overloads te vergelijken.

Gerelateerde lessen

  • C++ · Les 24 · Gevorderd · Versie: 3

Bronnen