Base di conoscenzaCentro esami
ITItaliano
Scegli la lingua13

CKTIS / C++

std::reference_wrapper — un wrapper di riferimento copiabile

std::reference_wrapper memorizza un riferimento senza possedere l’oggetto di destinazione. Scopri std::ref, std::cref e la differenza tra modificare l’oggetto referenziato e cambiare l’oggetto a cui fa riferimento il wrapper.

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

Sintassi

#include <functional>
std::reference_wrapper<T> wrapper = std::ref(object);
std::reference_wrapper<const T> readonly = std::cref(object);
wrapper.get();

std::reference_wrapper<T> di <functional> è un oggetto copiabile e assegnabile che racchiude un riferimento a un oggetto o a una funzione. Una copia continua a riferirsi alla stessa destinazione; non la copia. È utile quando occorre rappresentare un riferimento come un normale valore, per esempio in un contenitore. Se l’oggetto racchiuso è invocabile, operator() inoltra la chiamata alla destinazione.

std::ref(x) crea un std::reference_wrapper<T> preservando i qualificatori di tipo di x; non rimuove const. std::cref(x) crea un std::reference_wrapper<const T>, che consente di accedere a un oggetto tramite un riferimento a un tipo qualificato const. Un membro dati dichiarato mutable può comunque essere modificato direttamente tramite il riferimento restituito da get(). Gli overload che accettano un wrapper esistente ne conservano la destinazione invece di crearne uno annidato.

get() restituisce T&; è disponibile anche una conversione implicita a T&. Un const std::reference_wrapper<T> non aggiunge di per sé const al tipo a cui si riferisce. Per accedere all’oggetto tramite un riferimento a const T, usa std::reference_wrapper<const T>. L’assegnazione r = std::ref(b) cambia la destinazione del wrapper, mentre r.get() = b assegna un valore alla destinazione corrente.

Il wrapper non gestisce né prolunga la durata della destinazione. La destinazione deve esistere ogni volta che si usa il riferimento; altrimenti il riferimento diventa pendente. Gli overload eliminati di std::ref e std::cref impediscono di usare normali oggetti temporanei come destinazione. Gli overload che ricevono uno std::reference_wrapper, invece, accettano wrapper temporanei. Se a è un oggetto esistente di tipo int, sia std::ref(std::ref(a)) sia std::cref(std::ref(a)) sono espressioni valide e fanno riferimento ad a. Il wrapper non ha né un costruttore predefinito né uno stato vuoto.

Questa voce riguarda C++23. La fonte eel.is è una bozza in evoluzione e può contenere aggiunte successive; questa voce non ne presuppone la disponibilità.

Esempi

#include <functional>
#include <iostream>

int main() {
    int a = 10;
    int b = 20;
    auto r = std::ref(a);
    auto copy = r;
    const auto readonly = std::cref(a);

    copy.get() += 5;
    r = std::ref(b);
    r.get() += 2;

    std::cout << a << ' ' << b << ' ' << readonly.get() << '\n';
}

Risultato

15 22 15

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