Base de connaissancesCentre d’examen
FRFrançais
Choisir la langue13

CKTIS / C++

std::reference_wrapper — un wrapper de référence copiable

std::reference_wrapper stocke une référence sans posséder l’objet cible. Découvrez std::ref, std::cref et la différence entre modifier l’objet référencé et changer l’objet auquel le wrapper fait référence.

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

Syntaxe

#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> de <functional> est un objet copiable et assignable qui encapsule une référence vers un objet ou une fonction. Une copie fait toujours référence à la même cible ; elle ne copie pas cette cible. C’est utile lorsqu’une référence doit être représentée comme une valeur ordinaire, par exemple dans un conteneur. Pour un objet appelable encapsulé, operator() transmet l’appel à la cible.

std::ref(x) crée un std::reference_wrapper<T> en conservant les qualificatifs de type de x ; il ne supprime pas const. std::cref(x) crée un std::reference_wrapper<const T>, qui donne accès à un objet par une référence à un type qualifié const. Il reste possible de modifier directement un membre de données déclaré mutable par la référence renvoyée par get(). Les surcharges qui acceptent un wrapper existant conservent sa cible au lieu de créer un wrapper imbriqué.

get() renvoie T& ; une conversion implicite vers T& est également disponible. Un const std::reference_wrapper<T> n’ajoute pas en lui-même le qualificatif const au type référencé. Pour accéder à l’objet par une référence à const T, utilisez std::reference_wrapper<const T>. L’affectation r = std::ref(b) change la cible du wrapper, tandis que r.get() = b affecte une valeur à sa cible actuelle.

Le wrapper ne gère pas la durée de vie de sa cible et ne la prolonge pas. La cible doit exister chaque fois que la référence est utilisée ; sinon, la référence devient pendante. Les surcharges supprimées de std::ref et de std::cref empêchent de prendre un objet temporaire ordinaire pour cible. Les surcharges qui prennent un std::reference_wrapper acceptent toutefois les wrappers temporaires. Si a est un objet existant de type int, std::ref(std::ref(a)) et std::cref(std::ref(a)) sont tous deux valides et font référence à a. Le wrapper n’a ni constructeur par défaut ni état vide.

Cette entrée porte sur C++23. La source eel.is est un brouillon en évolution et peut contenir des ajouts ultérieurs ; cette entrée ne présume pas qu’ils soient disponibles.

Exemples

#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';
}

Résultat

15 22 15

Le code affiché et le résultat déclaré ont été vérifiés dans un environnement isolé selon la méthode consignée dans la preuve de vérification de cette version exacte.

Sources