Base di conoscenzaCentro esami
ITItaliano
Scegli la lingua13

CKTIS / C++

Riferimento di forwarding T&&

Un riferimento di forwarding T&& consente a un template di accettare lvalue e rvalue conservando le informazioni necessarie per inoltrare l’argomento. Richiede il contesto di deduzione appropriato; && da solo non basta.

Versione: C++23; repository compiler flag, production runtime not attested

Sintassi

template<class T>
void relay(T&& value);

In template<class T> void relay(T&& value);, il parametro T&& è un riferimento di forwarding (Forwarding reference T&&): si riferisce a un parametro template senza qualificatori const o volatile aggiunti. Quando T viene dedotto dall’argomento della chiamata, il meccanismo gestisce sia lvalue sia rvalue.

Per un lvalue di tipo int, la deduzione produce T = int& e il collasso dei riferimenti trasforma T&& in int&. Per un lvalue di tipo const int, il risultato è T = const int& e il parametro è const int&. Per un rvalue di tipo int, otteniamo T = int e un parametro int&&. Nel collasso dei riferimenti, la presenza di & produce &; solo la combinazione di due && produce &&.

Non ogni && indica un riferimento di forwarding: const T&& e int&& non lo sono. In template<class T> struct Box { void set(T&&); };, neppure il parametro di set lo è: T proviene dal template di classe, non viene dedotto durante la chiamata a set. Durante la deduzione degli argomenti di un template di classe, si applica un’esclusione ai parametri di quel template. Anche specificare esplicitamente relay<int>(x) evita la deduzione di T e non consente di legare l’lvalue x a int&&.

Nell’esempio, l’espressione value è un lvalue anche quando il tipo del parametro è int&&. std::forward<T>(value) inoltra un lvalue come lvalue e un rvalue come xvalue, preservando i qualificatori di tipo. Un semplice inspect(value) selezionerebbe un overload per lvalue anche dopo relay(42). std::move(value) converte incondizionatamente l’espressione in un xvalue, quindi non sostituisce il forwarding corretto. Il forwarding non prolunga automaticamente la durata di un oggetto; non conservare un riferimento a un oggetto temporaneo oltre la sua durata.

Esempi

#include <iostream>
#include <utility>

void inspect(int&) { std::cout << "lvalue\n"; }
void inspect(const int&) { std::cout << "const lvalue\n"; }
void inspect(int&&) { std::cout << "rvalue\n"; }

template<class T>
void relay(T&& value) {
    inspect(std::forward<T>(value));
}

int main() {
    int x = 7;
    const int cx = 9;
    relay(x);
    relay(cx);
    relay(42);
}

Risultato

lvalue
const lvalue
rvalue

Il codice mostrato e il risultato dichiarato sono stati verificati in un ambiente isolato con il metodo registrato nella prova di verifica di questa versione esatta.

Fonti