Caché en C++: acelera tus aplicaciones 10 veces

Caché de datos en C++: cuando la memoria es más rápida que el disco

Imagina que tu aplicación C++ es un bibliotecario. Cada vez que un lector pide un libro, el bibliotecario corre a un lejano depósito (léase: base de datos o sistema de archivos). Esto es lento. Pero si el bibliotecario comienza a tener los libros más populares en su escritorio (en la memoria RAM), la velocidad de entrega aumentará enormemente. Esto es el caché de datos en C++.

Hoy hablaremos sobre cómo transformar tu aplicación de una tortuga en un guepardo. Analizaremos no solo la teoría, sino que también escribiremos código real. Aprenderás qué estrategias de caché existen, cómo no dispararte en el pie al trabajar con memoria y dónde encontrar soluciones listas para no reinventar la rueda.

¿Por qué el caché es imprescindible para el desarrollador de C++?

C++ es un lenguaje para sistemas de alta carga. Robots de trading, motores de juegos, servidores de bases de datos: en todos los lugares donde cada microsegundo importa, el caché se convierte en un salvavidas. Sin él, constantemente te toparás con operaciones de I/O (entrada/salida) o cálculos repetitivos.

Los principales beneficios de implementar un caché:

• Reducción del tiempo de respuesta — los datos desde la RAM se leen 100 000 veces más rápido que desde un HDD.
• Disminución de la carga en la base de datos — menos consultas = menos latencia.
• Ahorro de recursos computacionales — no es necesario recalcular funciones pesadas.

Pero también hay trampas: fugas de memoria, datos obsoletos (stale data) y caídas de rendimiento con una implementación incorrecta. Por lo tanto, analicemos esto en orden.

Estrategias principales de caché en C++

La elección de la estrategia depende de qué datos estás almacenando en caché y con qué frecuencia cambian. Veamos las tres más populares.

1. LRU (Least Recently Used) — elimina lo que no se ha consultado durante más tiempo

Esto es un clásico. Imagina que tienes una caja para 10 libros. Cuando llega uno nuevo y la caja está llena, tiras el libro que no has leído durante más tiempo. El caché LRU en C++ funciona igual.

Implementación en C++ usando std::list y std::unordered_map:

#include <iostream>#include <list>#include <unordered_map>#include <string>

template <typename K, typename V>class LRUCache {private:    size_t capacity;    std::list<std::pair<K, V>> items;    std::unordered_map<K, typename std::list<std::pair<K, V>>::iterator> cache;

public:    LRUCache(size_t cap) : capacity(cap) {}

    V get(const K& key) {        auto it = cache.find(key);        if (it == cache.end()) {            return V(); // Devuelve el valor por defecto si la clave no se encuentra        }        // Mueve el elemento al inicio de la lista (el más reciente)        items.splice(items.begin(), items, it->second);        return it->second->second;    }

    void put(const K& key, const V& value) {        auto it = cache.find(key);        if (it != cache.end()) {            // Actualiza el elemento existente            it->second->second = value;            items.splice(items.begin(), items, it->second);            return;        }

        if (cache.size() >= capacity) {            // Elimina el elemento más antiguo (el último de la lista)            auto last = items.back();            cache.erase(last.first);            items.pop_back();        }

        // Inserta el nuevo elemento al inicio        items.emplace_front(key, value);        cache[key] = items.begin();    }};

int main() {    LRUCache<std::string, int> lru(3);    lru.put("one", 1);    lru.put("two", 2);    lru.put("three", 3);    lru.get("one"); // Accede a "one" — se vuelve reciente    lru.put("four", 4); // Se eliminará "two", ya que no se ha accedido a él durante más tiempo\