Reenvío perfecto
Parte de la sección Programación Orientada a Objetos del Journey de C++ de Coddy. Lección 84 de 104.
Al escribir funciones de plantilla que aceptan argumentos y los pasan a otras funciones, surge un problema: ¿cómo se conserva si el argumento original era un lvalue o un rvalue? El reenvío perfecto resuelve este problema pasando los argumentos exactamente tal como se recibieron y manteniendo su categoría de valor.
Los elementos clave son las referencias de reenvío (escritas como T&& en un contexto de plantilla) y std::forward. Una referencia de reenvío puede enlazarse tanto a lvalues como a rvalues, y std::forward convierte condicionalmente el argumento a su tipo original:
#include <iostream>
#include <utility>
void process(int& x) { std::cout << "lvalue: " << x << "\n"; }
void process(int&& x) { std::cout << "rvalue: " << x << "\n"; }
template<typename T>
void wrapper(T&& arg) {
process(std::forward<T>(arg));
}
int main() {
int n = 10;
wrapper(n); // Llama a process(int&) - se conserva el lvalue
wrapper(20); // Llama a process(int&&) - se conserva el rvalue
}Sin std::forward, los parámetros con nombre siempre son lvalues dentro de la función, incluso si se pasó un rvalue. Esto impediría que la semántica de movimiento funcionara correctamente al reenviar a constructores u otras funciones.
El reenvío perfecto es esencial para escribir funciones de fábrica, clases envoltorio y cualquier código genérico que necesite construir objetos o invocar funciones preservando la intención del llamador con respecto a los movimientos y las copias.
Desafío
FácilConstruyamos una función de fábrica que demuestre el reenvío perfecto creando objetos y preservando la categoría de valor de los argumentos que se le pasan. Crearás una función genérica make_object que reenvía argumentos a un constructor de clase, asegurándose de que los lvalues se copien y los rvalues se muevan.
Organizarás tu código en tres archivos:
Widget.h: Define una claseWidgetque registra cómo recibe sus datos.Tu
Widgetdebe almacenar un nombrestd::stringy un valorint. Proporciona dos constructores:- Uno que recibe
const std::string&(referencia lvalue) yint: imprimeWidget constructed (copy): [name] - Uno que recibe
std::string&&(referencia rvalue) yint: imprimeWidget constructed (move): [name]y mueve la cadena
Añade también un método
display()que imprima[name]: [value].- Uno que recibe
Factory.h: Crea tu función de fábrica con reenvío perfecto.Escribe una función plantilla
make_objectque acepte una referencia de reenvío para el nombre y unintnormal para el valor. Usastd::forwardpara pasar el argumento del nombre al constructor deWidgetpreservando su categoría de valor original.La función debe devolver el
Widgetconstruido por valor.main.cpp: Lee dos entradas:- Un nombre (cadena)
- Un valor (entero)
Demuestra el reenvío perfecto creando dos widgets:
- Primero, almacena el nombre en una variable local y pásalo a
make_objectcomo lvalue - Segundo, pasa una cadena temporal (el mismo nombre concatenado con
"_temp") directamente amake_objectcomo rvalue
Después de crear cada widget, llama a su método
display().
Por ejemplo, con las entradas Gadget y 42:
Widget constructed (copy): Gadget
Gadget: 42
Widget constructed (move): Gadget_temp
Gadget_temp: 42Con las entradas Device y 100:
Widget constructed (copy): Device
Device: 100
Widget constructed (move): Device_temp
Device_temp: 100La idea clave es que tu función make_object no sabe si recibió un lvalue o un rvalue, pero al usar std::forward, preserva esa información al llamar al constructor de Widget. Esto permite que la resolución de sobrecargas del constructor seleccione la versión adecuada, lo que habilita movimientos eficientes para los temporales y copias seguras para las variables con nombre.
Pruébalo tú mismo
#include <iostream>
#include <string>
#include "Widget.h"
#include "Factory.h"
using namespace std;
int main() {
// Lee la entrada
string name;
int value;
cin >> name >> value;
// TODO: Crea el primer widget pasando name como lvalue
// Guarda el nombre en una variable local y pásalo a make_object
// TODO: Llama a display() en el primer widget
// TODO: Crea el segundo widget pasando una cadena temporal como rvalue
// Pasa (name + "_temp") directamente a make_object
// TODO: Llama a display() en el segundo widget
return 0;
}
Esta lección incluye un breve cuestionario. Empieza la lección para responderlo y registrar tu progreso.
Todas las lecciones de Programación Orientada a Objetos
1Fundamentos de la POO
Archivos externosCompilación y construcción en C++Archivos de cabecera y archivos fuenteEspacios de nombres y ámbitoIntroducción a la POO en C++Clases y objetosEl puntero 'this'Métodos (funciones miembro)Atributos (miembros de datos)Fundamentos de constructores y destructoresRepaso: calculadora sencilla4Propiedades de clase
Miembros de instancia vs. estáticosGetters y settersFunciones miembro constPalabra clave mutableMétodos y variables estáticosFunciones y clases friendRepaso: gestor de cuentas bancarias7Herencia
Herencia básicaNiveles de acceso en la herenciaOrden de llamada de constructores y destructoresSobrescritura de métodosFunciones virtuales y VTableHerencia múltipleHerencia virtualRepaso: jerarquía de empleados2Gestión de memoria
Memoria de pila vs. heapPunteros y referenciasMemoria dinámica (new/delete)Punteros inteligentes en C++RAII en C++Repaso: gestor de arreglos dinámicos5Encapsulación
Especificadores de acceso en C++Especificadores de acceso en profundidadOcultación de informaciónStruct vs. classClases anidadas e internasRepaso: sistema de registros de estudiantes8Polimorfismo
Polimorfismo en compilación y en tiempo de ejecuciónSobrecarga de funcionesRepaso de las funciones virtualesFunciones virtuales purasClases abstractasDiseño de interfaces en C++Conversión dinámica y RTTIRepaso: calculadora de formas11Conceptos avanzados de POO
Composición frente a herenciaMixins mediante CRTPIdiom PimplBorrado de tiposClases enum y tipado fuerteManejo de excepciones en POOJerarquías de excepciones personalizadas14Patrones de diseño, parte 2
Patrón CommandPatrón AdapterPatrón DecoratorPatrón Template MethodPatrón StatePatrón CompositeRAII como patrón3Constructores y destructores
Constructor predeterminadoConstructor con parámetrosConstructor de copiaConstructor de movimientoListas de inicialización del constructorConstructores delegadosAnálisis detallado del destructorRegla de tres / cinco / ceroRepaso: clase String6Sobrecarga de operadores
Introducción a la sobrecarga de operadoresSobrecarga de operadores aritméticosSobrecarga de operadores de comparaciónOperadores de flujoSobrecarga del operador de asignaciónSobrecarga de los operadores [] y ()Operadores de conversión de tipoRepaso: clase Matrix9Plantillas
Plantillas de funcionesPlantillas de clasesEspecialización de plantillasPlantillas variádicasFundamentos de SFINAE y rasgos de tiposRepaso: contenedor genérico12Características modernas de C++
Semántica de movimiento y rvaluesReenvío perfectoExpresiones lambda en profundidadstd::function y std::bindconstexpr y constevalDescomposición estructuradaoptional, variant, anyPractica por tu cuenta: Compilador de C++ online