¿Qué punteros inteligentes existen en C++?

std::unique_ptr, std::shared_ptr, std::weak_ptr.

• std::unique_ptr:

  • Propiedad exclusiva del objeto.
  • No puede ser copiado, pero puede ser movido (std::move).
  • Elimina automáticamente el objeto al salir del ámbito o destruirse unique_ptr.
  • Es liviano, sin costos adicionales en el contador de referencias.

  #include <memory>
  
  // Creación de unique_ptr
  std::unique_ptr<int> up1(new int(10));
  
  // Movimiento de propiedad
  std::unique_ptr<int> up2 = std::move(up1);
  
  // up1 ahora es nullptr
  // up2 posee el objeto
  

• std::shared_ptr:

  • Propiedad compartida del objeto.
  • Usa un contador de referencias para rastrear cuántos shared_ptr apuntan al recurso.
  • El objeto se elimina cuando el último shared_ptr que lo apunta se destruye.
  • Se puede copiar y mover.
  • Tiene costos adicionales en el contador de referencias (generalmente asignado por separado).
  • Puede formar referencias cíclicas, lo que lleva a fugas de memoria.

  #include <memory>
  
  // Creación de shared_ptr
  std::shared_ptr<int> sp1 = std::make_shared<int>(20);
  
  // Copiar propiedad
  std::shared_ptr<int> sp2 = sp1; // El contador de referencias aumenta
  
  // sp1 y sp2 poseen el objeto
  

• std::weak_ptr:

  • No posee el objeto.
  • Representa una "referencia débil" al objeto, gestionado por uno o varios shared_ptr.
  • Se usa para prevenir referencias cíclicas entre shared_ptr.
  • No incrementa el contador de referencias del objeto.
  • Para acceder de forma segura al objeto, se convierte en shared_ptr usando el método lock(). Si el objeto ya fue eliminado, lock() devolverá un shared_ptr vacío.

  #include <memory>
  
  // Creación de shared_ptr
  std::shared_ptr<int> sp = std::make_shared<int>(30);
  
  // Creación de weak_ptr desde shared_ptr
  std::weak_ptr<int> wp = sp;
  
  // Verificación y uso del objeto
  if (auto shared_from_weak = wp.lock()) {
      // Acceso al objeto a través de shared_from_weak
  } else {
      // El objeto ya fue eliminado
  }