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.