Base de conocimientosCentro de exámenes
ESEspañol
Elegir idioma13

CKTIS / C++

std::reference_wrapper — un envoltorio de referencia copiable

std::reference_wrapper almacena una referencia sin poseer el objeto al que apunta. Aprende sobre std::ref, std::cref y la diferencia entre modificar el objeto referenciado y cambiar a qué objeto hace referencia el envoltorio.

Versión: C++23; repository compiler flag, production runtime not attested

Sintaxis

#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> es un objeto copiable y asignable que envuelve una referencia a un objeto o una función. Una copia sigue haciendo referencia al mismo destino; no lo copia. Es útil cuando hay que representar una referencia como un valor normal, por ejemplo, en un contenedor. Si el destino envuelto es invocable, operator() reenvía la llamada a dicho destino.

std::ref(x) crea un std::reference_wrapper<T> y conserva los calificadores de tipo de x; no elimina const. std::cref(x) crea un std::reference_wrapper<const T>, que da acceso a un objeto mediante una referencia a un tipo calificado con const. Un miembro de datos declarado mutable aún se puede modificar directamente a través de la referencia que devuelve get(). Las sobrecargas que aceptan un envoltorio existente conservan su destino, en lugar de crear un envoltorio anidado.

get() devuelve T&; también está disponible una conversión implícita a T&. Un const std::reference_wrapper<T> no añade por sí solo const al tipo referenciado. Para acceder al objeto mediante una referencia a const T, usa std::reference_wrapper<const T>. La asignación r = std::ref(b) cambia el destino del envoltorio, mientras que r.get() = b asigna un valor a su destino actual.

El envoltorio no administra ni prolonga la duración del destino. El destino debe existir siempre que se use la referencia; de lo contrario, esta queda colgante. Las sobrecargas eliminadas de std::ref y std::cref impiden usar objetos temporales ordinarios como destino. Sin embargo, las sobrecargas que reciben un std::reference_wrapper aceptan envoltorios temporales. Si a es un objeto existente de tipo int, tanto std::ref(std::ref(a)) como std::cref(std::ref(a)) son expresiones válidas y hacen referencia a a. El envoltorio no tiene constructor predeterminado ni estado vacío.

Esta entrada se refiere a C++23. La fuente eel.is es un borrador en evolución y puede incluir adiciones posteriores; esta entrada no presupone que estén disponibles.

Ejemplos

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

Resultado

15 22 15

El código mostrado y el resultado declarado se verificaron en un entorno aislado mediante el método registrado en la evidencia de verificación de esta versión exacta.

Fuentes