Guía de Seguridad de Memoria

// PELIGRO: raw pointer, sin ownership claro
class TensorPool {
public:
  float* allocate(size_t n) {
    return new float[n]; // ¿quién libera?
  }

  void release(float* ptr) {
    delete[] ptr; // ¿ya fue liberado?
  }

  // BUG: si release() ya se llamó,
  // el caller puede seguir usando ptr
  // → USE-AFTER-FREE
};

class TensorPool {
public:
  // Ownership TRANSFERIDO al caller
  std::unique_ptr<float[]> allocate(size_t n) {
    return std::make_unique<float[]>(n);
  }

  // No hace falta release():
  // destructor libera automáticamente
  // Use-after-free: imposible
  // Double-free: imposible
  // Leak en ruta de error: imposible
};

class ModelRegistry {
  std::map<string, Model*> cache_;

public:
  // BUG: lectura y escritura sin lock
  // → DATA RACE si hay >1 thread
  Model* get(const string& id) {
    return cache_[id]; // race!
  }

  void set(const string& id, Model* m) {
    cache_[id] = m; // race!
  }
};

class ModelRegistry {
  std::map<string, shared_ptr<Model>> cache_;
  mutable std::shared_mutex mutex_;

public:
  // Múltiples lectores simultáneos OK
  shared_ptr<Model> get(const string& id) const {
    std::shared_lock lock(mutex_);
    auto it = cache_.find(id);
    return it != cache_.end() ? it->second : nullptr;
  }

  void set(const string& id, shared_ptr<Model> m) {
    std::unique_lock lock(mutex_); // escritor exclusivo
    cache_[id] = std::move(m);
  }
};

// COMPILE ERROR: Rust no lo permite
fn get_sensor_ref() -> &SensorData {
  let data = SensorData::new(); // local
  &data // ERROR: dangling reference
  // data se destruye al salir de scope
}

// En C++ esto compila pero es UB
// En Rust el borrow checker lo rechaza

use std::sync::{Arc, RwLock};

pub struct SensorBridge {
  buffer: Arc<RwLock<Vec<SensorFrame>>>,
}

impl SensorBridge {
  pub fn push(&self, frame: SensorFrame) {
    let mut buf = self.buffer.write().unwrap();
    buf.push(frame); // sin race, garantizado
  }

  // Clone barato: incrementa ref-count
  pub fn reader(&self) -> Arc<RwLock<...>> {
    Arc::clone(&self.buffer)
  }
}

void runInference(Model* model) {
  float* input  = new float[1024];
  float* output = new float[512];

  // Si esto lanza excepción:
  model->forward(input, output);

  // ← NUNCA llega aquí → LEAK
  delete[] input;
  delete[] output;
}

void runInference(Model& model) {
  // Destructor llamado SIEMPRE,
  // incluso con excepciones
  auto input  = std::make_unique<float[]>(1024);
  auto output = std::make_unique<float[]>(512);

  // excepción aquí → destructores
  // liberan input y output
  model.forward(input.get(), output.get());
  // Sin leak posible
}