Base di conoscenzaCentro esami
ITItaliano
Scegli la lingua13

CKTIS / C++

Il riferimento di inoltro `F&&`

Quando `F` viene dedotto, `F&&` può legarsi sia a un lvalue sia a un rvalue. `f()` tratta l’oggetto invocabile come lvalue; `std::forward<F>(f)` lo inoltra come lvalue o rvalue in base all’argomento.

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

Sintassi

#include <utility>

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

In template<class F> void call(F&& f), f è un riferimento di inoltro: && si applica direttamente al parametro di tipo F, senza aggiungere const o volatile, e F viene dedotto alla chiamata. Per un lvalue di tipo T, si deduce F = T& e il collasso dei riferimenti dà a f il tipo T&. Per un rvalue di tipo T, si deduce F = T, quindi f ha tipo T&&. I qualificatori del tipo dell’argomento, come const, vengono conservati.

La sola presenza di && non basta. const F&&, un tipo concreto come Callable&& e F&& quando F è già fissato da una specializzazione del template di classe non sono riferimenti di inoltro.

In f(), l’espressione f è un lvalue anche se il tipo dichiarato del parametro è Callable&&. std::forward<F>(f), definito in <utility>, usa il tipo F dedotto: per gli oggetti produce un lvalue se l’argomento era un lvalue e un xvalue (un tipo di rvalue) se era un rvalue. Questo può cambiare quale overload viene selezionato: operator()() & oppure operator()() &&.

std::forward di per sé non copia né sposta l’oggetto e non ne prolunga la durata. Un oggetto temporaneo legato a un parametro di riferimento esiste fino alla fine dell’espressione completa che contiene la chiamata. Un riferimento conservato a quell’oggetto diventa pendente dopo tale punto.

Esempi

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

Risultato

lvalue lvalue
lvalue rvalue

Ogni riga mostra prima il risultato di `f()` e poi quello di `std::forward<F>(f)()`. Per `callable` entrambe le chiamate selezionano `&`; per `Callable{}` la prima seleziona `&` e la seconda `&&`. L’oggetto viene invocato due volte solo per confrontare gli overload.

Lezioni correlate

  • C++ · Lezione 24 · Avanzato · Versione: 3

Fonti