Referencias rvalue y sintaxis &&
Vincúlese a temporales mediante referencias rvalue para transferir recursos de forma eficiente.
Referencias rvalue y sintaxis && es una lección gratuita de C++ Academy en CoddyKit. Esta es la lección 2 de 4. Puedes leer la lección completa abajo gratuitamente — luego la practicas en el navegador con un editor de código integrado y un tutor de IA 24/7. Forma parte de la ruta de aprendizaje de C++ Academy, y tu progreso se sincroniza en la web y la app de CoddyKit. El curso de C++ Academy incluye 4 lecciones en total.
La sintaxis &&
Una referencia rvalue se declara con T&&. Solo se vincula a rvalues, es decir, temporales a punto de destruirse.
int&& ref = 42; // OK: binds to literal
int x = 10;
// int&& bad = x; // ERROR: x is an lvalue¿Por qué existen las referencias rvalue?
Permiten escribir funciones que saben que el argumento está a punto de destruirse. Puede apropiarse de sus recursos sin hacer una copia.
Sobrecarga de funciones según el tipo de referencia
Puede sobrecargar una función usando T& y T&&. El compilador elige la adecuada según la categoría del argumento.
void process(std::string& s) { std::cout << "lvalue\n"; }
void process(std::string&& s) { std::cout << "rvalue\n"; }
std::string s = "hi";
process(s); // lvalue
process("temp"); // rvalue
process(std::move(s)); // rvalueLas referencias rvalue con nombre se convierten en lvalues
Cuando asigna un nombre a una referencia rvalue, ese nombre es un lvalue por sí mismo: su identidad ha quedado establecida. Use std::move para recuperar su naturaleza de rvalue.
void f(std::string&& s) {
// inside f, the parameter s is an lvalue
g(s); // passes s by lvalue
h(std::move(s)); // passes s as an rvalue
}std::move es una conversión
std::move(x) no mueve nada por sí mismo: es una conversión de tipo que devuelve x como una referencia rvalue. El movimiento real ocurre en el constructor que recibe el objeto.
// equivalent to
static_cast<std::string&&>(s)Por qué se llama move
El nombre refleja el uso habitual: pasar un objeto cuyos contenidos se pretende tomar, pero no transfiere nada por sí mismo.
Referencias universales (referencias de reenvío)
Cuando T&& aparece en una plantilla con un T deducido, es una referencia de reenvío: se vincula tanto a lvalues como a rvalues y conserva la categoría.
template <typename T>
void wrapper(T&& arg) {
process(std::forward<T>(arg));
}Colapso de referencias
Cuando las referencias se apilan mediante plantillas, el lenguaje las combina:
T& &→T&T& &&→T&T&& &→T&T&& &&→T&&
Cuándo no usar move
Para tipos que se pueden copiar trivialmente (int, double, punteros), mover equivale a copiar. Llamar a std::move no aporta ningún beneficio y puede confundir a quienes lean el código.
Mover sin ser propietario de recursos
En los tipos sin recursos en el heap, el constructor de movimiento es igual que el constructor de copia. Mover solo resulta beneficioso para los tipos que son propietarios de memoria dinámica.
Error habitual: mover desde const
std::move aplicado a un objeto const no tiene efecto: el constructor de movimiento no puede llamarse sobre un const porque necesitaría modificar el origen.
Comprobación rápida
¿Qué hace realmente std::move(x)?
Resumen
T&& se vincula a rvalues. Las referencias rvalue con nombre se convierten en lvalues; use std::move para recuperar su naturaleza de rvalue. T&& en una plantilla es una referencia de reenvío. std::move es una conversión; no realiza el movimiento por sí mismo.
Preguntas frecuentes
¿La lección «Referencias rvalue y sintaxis &&» es gratis?
Sí — el texto completo de «Referencias rvalue y sintaxis &&» es gratis para leer aquí en la web. Para practicarla de forma interactiva (editor de código integrado y tutor de IA 24/7) y desbloquear el resto del curso de C++ Academy, actualiza a CoddyKit PRO. El curso de C++ Academy incluye 4 lecciones en total.
¿Qué aprenderé en «Referencias rvalue y sintaxis &&»?
Vincúlese a temporales mediante referencias rvalue para transferir recursos de forma eficiente. Practicas C++ Academy con código real que ejecutas directamente en el navegador, y un tutor de IA 24/7 responde tus preguntas mientras trabajas en la lección.
¿Necesito experiencia previa para empezar C++ Academy?
No se requiere experiencia previa. C++ Academy en CoddyKit está estructurado para principiantes hasta estudiantes avanzados, así que puedes empezar aquí o desde el inicio y avanzar a tu ritmo. Esta es la lección 2 de 4.
¿Cuánto tiempo toma la lección «Referencias rvalue y sintaxis &&»?
La mayoría de las lecciones de CoddyKit toman alrededor de 5–10 minutos. Cada una es compacta e interactiva, así que avanzas constantemente y retomas exactamente por donde dejaste en la web y la app.
¿Puedo escribir y ejecutar código en esta lección de C++ Academy?
Sí. Cada lección de C++ Academy incluye un editor de código integrado, así que escribes y ejecutas código real directamente en tu navegador y obtienes retroalimentación instantánea de IA — sin configuración local necesaria.
Todas las lecciones de este curso
- Lvalue frente a rvalue: la diferencia
- Referencias rvalue y sintaxis &&
- std::move y std::forward
- Constructores de movimiento y asignación de movimiento