Move semantics, optional y variant

Un std::vector de un millón de double guarda sus datos en el heap y en el stack solo lleva tres cosas: el puntero al buffer, el tamaño y la capacidad. Copiarlo implica reservar otro millón de double y copiarlos uno a uno. Moverlo consiste en copiar esos tres valores y dejar el original vacío. Esa es toda la idea de move semantics.

El lenguaje necesita distinguir entre un objeto que seguirás usando y uno que ya no necesitas. A esa distinción la llamamos categoría de valor: un lvalue tiene nombre y dirección estable; un rvalue es un temporal que está a punto de desaparecer. std::move no mueve nada: convierte una expresión en un rvalue para que el compilador elija la versión de movimiento.

¿Qué es un rvalue?

Mira la expresión int x = 1 + 2;. x es un lvalue: puedes tomar su dirección, asignarle otro valor y seguir usándolo. 1 + 2 es un rvalue: no tiene nombre ni dirección propia, existe solo mientras se evalúa la expresión. Del mismo modo, std::string("hola") es un temporal, y el resultado de una función que devuelve por valor también lo es.

La biblioteca estándar aprovecha esa diferencia con la sobrecarga: si una función recibe T&, solo acepta lvalues; si recibe T&&, solo acepta rvalues. Así un contenedor puede copiar cuando le pasas algo que vas a conservar y robar los recursos cuando le pasas un temporal que ya nadie más va a usar.

1234567891011121314

#include <iostream>
#include <utility>

void tipo(int&)  { std::cout << "lvalue\n"; }
void tipo(int&&) { std::cout << "rvalue\n"; }

int main() {
    int x = 1;

    tipo(x);             // lvalue: tiene nombre
    tipo(2);             // rvalue: literal temporal
    tipo(std::move(x));  // rvalue: lo declaramos prescindible
    return 0;
}

¿Para qué sirve mover?

• Evitar copias costosas: devolver un vector de una función, insertarlo en otro contenedor o reasignarlo no duplica el buffer.
• Transferir propiedad: un unique_ptr no se puede copiar, pero sí mover; el movimiento expresa «ahora el recurso es tuyo».
• Hacer eficientes los contenedores: cuando un vector crece, mueve sus elementos al buffer nuevo si el movimiento es noexcept; si no, los copia.
• Separar lectura de consumo: una función que recibe const T& observa; una que recibe T&& puede quedarse con el recurso.
• Modelar resultados: std::optional evita valores centinela y std::variant guarda alternativas sin jerarquía de clases.

Cómo funciona por dentro: robo de recursos y RVO

Un constructor de movimiento recibe T&&, copia los punteros del origen y deja el origen en un estado válido pero vacío. «Válido» significa que puedes destruirlo o asignarle un valor nuevo; «no especificado» significa que no debes asumir que conserva el contenido anterior. Para un std::string, el estándar permite que el origen quede vacío, pero no lo garantiza en todas las implementaciones.

El movimiento debe ser noexcept siempre que sea posible. std::vector lo comprueba: al reasignar, si el constructor de movimiento puede lanzar, prefiere copiar para mantener la garantía fuerte de excepción. Un noexcept ausente puede convertir una operación lineal en una copia completa sin que te des cuenta.

La otra pieza es la elisión de copia. Desde C++17, Buffer b = crear(); construye el objeto directamente en el destino: no hay copia ni movimiento que elidir, es obligatorio. Por eso nunca escribas return std::move(local); dentro de una función que devuelve por valor: impides la elisión y fuerzas un movimiento que no hacía falta.

Sintaxis: std::move, constructor de movimiento y forwarding

Un constructor de movimiento se declara T(T&& otro) noexcept. Si escribes uno, el compilador no genera la copia; si quieres prohibirla, bórrala con = delete. La asignación de movimiento debe liberar el recurso actual antes de robar el del otro y comprobar la autoasignación.

El forwarding perfecto aparece en plantillas que reenvían argumentos sin perder su categoría. T&& en un contexto deducido es una referencia universal: si le pasas un lvalue, T se deduce como U& y la referencia colapsa a U&; si le pasas un rvalue, T es U y queda U&&. std::forward<T> conserva esa categoría al llamar a la siguiente función.

1234567891011121314151617

#include <iostream>
#include <utility>

void procesar(int&)  { std::cout << "lvalue\n"; }
void procesar(int&&) { std::cout << "rvalue\n"; }

template <typename T>
void envolver(T&& valor) {
    procesar(std::forward<T>(valor));
}

int main() {
    int x = 1;
    envolver(x);   // lvalue
    envolver(2);   // rvalue
    return 0;
}

Ejemplo básico: mover un buffer

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051

#include <cstddef>
#include <iostream>
#include <utility>

class Buffer {
public:
    explicit Buffer(std::size_t n) : datos_(new int[n]), n_(n) {
        std::cout << "constructor " << n_ << '\n';
    }
    ~Buffer() { delete[] datos_; }

    Buffer(const Buffer&) = delete;
    Buffer& operator=(const Buffer&) = delete;

    Buffer(Buffer&& otro) noexcept : datos_(otro.datos_), n_(otro.n_) {
        otro.datos_ = nullptr;
        otro.n_ = 0;
        std::cout << "move " << n_ << '\n';
    }

    Buffer& operator=(Buffer&& otro) noexcept {
        if (this != &otro) {
            delete[] datos_;
            datos_ = otro.datos_;
            n_ = otro.n_;
            otro.datos_ = nullptr;
            otro.n_ = 0;
        }
        return *this;
    }

    std::size_t tamano() const { return n_; }

private:
    int* datos_;
    std::size_t n_;
};

Buffer crear(std::size_t n) {
    return Buffer(n);   // elision garantizada: no hay move
}

int main() {
    Buffer a(4);
    Buffer b(std::move(a));
    std::cout << a.tamano() << ' ' << b.tamano() << '\n'; // 0 4

    Buffer c = crear(3);
    std::cout << c.tamano() << '\n';                      // 3
    return 0;
}

Al ejecutar este programa, la salida es constructor 4, move 4, 0 4, constructor 3 y 3. Fíjate en que crear(3) imprime el constructor pero ningún move: la elisión construyó c directamente. Esa es la diferencia entre mover y no mover en absoluto.

1. Buffer a(4) reserva 4 enteros y guarda el puntero en a.
2. Buffer b(std::move(a)) elige el constructor Buffer&&; b copia el puntero y a se queda con nullptr.
3. a.tamano() devuelve 0 y b.tamano() devuelve 4: el recurso cambió de dueño.
4. crear(3) devuelve un prvalue; el compilador construye c en su lugar final sin llamar al constructor de movimiento.
5. Al final del programa, los destructores liberan cada buffer una sola vez: a libera nullptr y b libera el bloque original.

Ejemplo intermedio: optional y variant

std::optional<T> representa un T que puede no existir. Sustituye a los centinelas (-1, cadena vacía, NaN) y obliga a comprobar antes de leer. Tiene un coste: guarda el valor y un booleano, y no reserva en el heap.

1234567891011121314151617181920212223

#include <iostream>
#include <optional>

std::optional<double> dividir(double a, double b) {
    if (b == 0.0) {
        return std::nullopt;
    }
    return a / b;
}

int main() {
    if (auto r = dividir(10.0, 4.0)) {
        std::cout << *r << '\n';        // 2.5
    }

    if (!dividir(1.0, 0.0)) {
        std::cout << "sin resultado\n";
    }

    auto r = dividir(9.0, 3.0);
    std::cout << r.value_or(-1.0) << '\n'; // 3
    return 0;
}

std::variant<A, B, C> guarda exactamente una de las alternativas, sin herencia ni punteros. Es una unión segura: sabe qué tipo contiene y lo destruye correctamente. Para operar sobre él se usa std::visit, que llama a un callable con el valor activo, o std::get_if cuando quieres comprobar sin excepciones.

12345678910111213141516171819202122232425262728

#include <iostream>
#include <string>
#include <variant>

using Valor = std::variant<int, double, std::string>;

void imprimir(const Valor& v) {
    std::visit([](const auto& x) {
        std::cout << x << '\n';
    }, v);
}

int main() {
    Valor a = 42;
    Valor b = 3.5;
    Valor c = std::string("modelo");

    imprimir(a);
    imprimir(b);
    imprimir(c);

    std::cout << std::get<double>(b) << '\n'; // 3.5

    if (const auto* p = std::get_if<int>(&a)) {
        std::cout << *p + 1 << '\n';          // 43
    }
    return 0;
}

Caso práctico: un valor de configuración

Imagina un parámetro de un modelo que puede venir como entero, como real o como texto: el número de árboles, la tasa de aprendizaje o el nombre de la función de pérdida. Un variant modela esa situación sin una jerarquía de clases y sin void*. La visita con sobrecargas devuelve una descripción legible.

1234567891011121314151617181920212223242526272829303132

#include <iomanip>
#include <iostream>
#include <sstream>
#include <string>
#include <variant>

using Config = std::variant<int, double, std::string>;

struct Describir {
    std::string operator()(int v) const {
        return "entero: " + std::to_string(v);
    }
    std::string operator()(double v) const {
        std::ostringstream os;
        os << std::fixed << std::setprecision(1) << v;
        return "real: " + os.str();
    }
    std::string operator()(const std::string& v) const {
        return "texto: " + v;
    }
};

int main() {
    Config a = 100;
    Config b = 0.05;
    Config c = std::string("mse");

    for (const Config& valor : {a, b, c}) {
        std::cout << std::visit(Describir{}, valor) << '\n';
    }
    return 0;
}

La salida es entero: 100, real: 0.1 y texto: mse. Ojo con el redondeo: 0.05 con una cifra decimal se muestra como 0.1 por la regla de redondeo de la biblioteca. Si el formato importa, usa más precisión o formatea en la capa de presentación, no en la lógica.

Visualización: el robo de un recurso

Este mapa muestra qué ocurre con el puntero interno cuando un Buffer se mueve. Ningún byte del array se copia: solo cambia quién lo posee. Avanza paso a paso y compara las direcciones.

Buffer a(4);
Buffer b(std::move(a));
std::cout << a.tamano() << ' ' << b.tamano();
Buffer c = crear(3);

Si en lugar de mover hubieras copiado, el paso 3 tendría un bloque nuevo en otra dirección y los dos objetos serían independientes. Mover no reduce el trabajo de reservar: lo elimina. Esa es la razón por la que importa en rutas calientes.

Errores comunes

• Creer que std::move mueve: solo cambia la categoría de la expresión. Si el tipo no tiene move, se copia y el programa sigue siendo correcto, solo más lento.
• Usar el objeto de origen después de moverlo: su estado es válido pero no especificado. No asumas que conserva el contenido ni que está vacío.
• Escribir return std::move(local);: impide la elisión de copia y puede empeorar el rendimiento. Devuelve local directamente.
• Mover un objeto const: std::move(const T) produce const T&&, que no enlaza con T&&; el constructor de copia se elige y no hay transferencia.
• Olvidar noexcept en el move: std::vector copiará al crecer. Es una penalización silenciosa y fácil de medir con un contador.
• Acceder a un optional vacío con * o value(): * es comportamiento indefinido y value() lanza std::bad_optional_access. Comprueba con if o usa value_or.
• Usar std::get<T> con el tipo equivocado en un variant: lanza std::bad_variant_access. Si el tipo es dinámico, usa std::get_if o std::visit.

1234

std::vector<int> crear() {
    std::vector<int> v(1000);
    return std::move(v);
}

1234

std::vector<int> crear() {
    std::vector<int> v(1000);
    return v;
}

Buenas prácticas

• Marca los constructores y asignaciones de movimiento como noexcept; es la señal que los contenedores necesitan.
• Deja el origen en un estado válido y documentado: nullptr y tamaño 0 es la convención más clara.
• Sigue la regla de cero: si puedes usar std::vector, std::string o unique_ptr, no escribas tu propio destructor ni tu propio move.
• Recibe const T& para observar y T&& solo cuando vayas a quedarte con el recurso.
• Usa std::forward<T> en plantillas que reenvían; std::move siempre convertiría, incluso los lvalues.
• Prefiere optional a punteros para valores ausentes y variant a jerarquías cuando las alternativas son cerradas.
• Visita el variant con std::visit y sobrecargas; evita cadenas de holds_alternative que crecen con cada tipo nuevo.

1234567

def dividir(a, b):
    if b == 0:
        return None
    return a / b

r = dividir(10, 4)
print(r if r is not None else "sin resultado")

1234567

std::optional<double> dividir(double a, double b) {
    if (b == 0.0) return std::nullopt;
    return a / b;
}

auto r = dividir(10.0, 4.0);
if (r) std::cout << *r;

Ejercicios

std::<double> resultado = dividir(8.0, 2.0);

if (resultado) {
    std::cout << resultado;   // 4
}

std::string nombre = "modelo";
std::string copia = std::(nombre);   // transferir, no copiar

Soluciones explicadas

En el ejercicio del buffer, la parte delicada es la asignación: si liberas antes de comprobar la autoasignación, b = std::move(b) destruiría su propio recurso y luego lo copiaría de sí mismo. La comprobación de identidad evita ese caso. Anular el origen no es opcional: si el destructor de a ejecutara delete[] sobre el mismo puntero que ahora usa b, tendrías una doble liberación.

En el variant, el struct de sobrecargas hace que el compilador elija la función según el tipo activo. La alternativa sería una lambda genérica con if constexpr, útil cuando las tres ramas son muy parecidas; con lógica distinta, las sobrecargas separadas se leen mejor. Si añades un tipo y olvidas la sobrecarga, el error de compilación es la señal de que el visitante está incompleto.

Resumen

• Un lvalue tiene nombre y dirección; un rvalue es un temporal o algo declarado prescindible.
• std::move es una conversión a T&&; el movimiento real lo hace el constructor o la asignación.
• Un move transfiere punteros y deja el origen válido pero sin recursos.
• noexcept en el move permite que los contenedores muevan en lugar de copiar al crecer.
• La elisión de copia construye el objeto en su destino; no escribas return std::move(local).
• std::optional modela un valor que puede faltar y obliga a comprobarlo.
• std::variant guarda una alternativa cerrada y std::visit la procesa sin herencia.

Evaluación