En esta página

QContiguousCache Class

template <typename T> class QContiguousCache

La clase QContiguousCache es una clase de plantilla que proporciona una caché contigua. Más información...

Encabezado: #include <QContiguousCache>
CMake: find_package(Qt6 REQUIRED COMPONENTS Core)
target_link_libraries(mytarget PRIVATE Qt6::Core)
qmake: QT += core

Nota: Todas las funciones de esta clase son reentrantes.

Funciones públicas

QContiguousCache(qsizetype capacity = 0)
QContiguousCache(const QContiguousCache<T> &other)
~QContiguousCache()
void append(const T &value)
bool areIndexesValid() const
const T &at(qsizetype i) const
qsizetype available() const
qsizetype capacity() const
void clear()
bool containsIndex(qsizetype i) const
qsizetype count() const
T &first()
const T &first() const
qsizetype firstIndex() const
void insert(qsizetype i, const T &value)
bool isEmpty() const
bool isFull() const
T &last()
const T &last() const
qsizetype lastIndex() const
void normalizeIndexes()
void prepend(const T &value)
void removeFirst()
void removeLast()
void setCapacity(qsizetype size)
qsizetype size() const
void swap(QContiguousCache<T> &other)
T takeFirst()
T takeLast()
bool operator!=(const QContiguousCache<T> &other) const
QContiguousCache<T> &operator=(QContiguousCache<T> &&other)
QContiguousCache<T> &operator=(const QContiguousCache<T> &other)
bool operator==(const QContiguousCache<T> &other) const
T &operator[](qsizetype i)
const T &operator[](qsizetype i) const

Descripción detallada

La clase QContiguousCache proporciona una forma eficaz de almacenar en caché elementos de tipo « T » para su visualización en una vista de la interfaz de usuario. A diferencia de ` QCache`, añade la restricción de que los elementos de la caché sean contiguos. Esto tiene la ventaja de ajustarse a la forma en que las vistas de la interfaz de usuario suelen solicitar datos: como un conjunto de filas situadas en torno a la posición actual de desplazamiento. Esta restricción permite que la caché consuma menos memoria y ciclos de procesador que ` QCache`.

`QContiguousCache` funciona con una capacidad fija, establecida mediante ` setCapacity()` o pasada como parámetro al constructor. Esta capacidad es el límite máximo de uso de memoria por parte de la propia caché, sin incluir la memoria asignada por los propios elementos. Ten en cuenta que una caché con una capacidad de cero (el valor por defecto) significa que no se almacenará ningún elemento: las operaciones insert(), append() y prepend() serán, en la práctica, operaciones nulas. Por lo tanto, es importante establecer la capacidad en un valor razonable antes de añadir elementos a la caché.

La forma más sencilla de utilizar una caché contigua es emplear las funciones append() y prepend().

MyRecord record(int row)
{
    Q_ASSERT(row >= 0 && row < cache.count());

    while (row > cache.lastIndex())
        cache.append(slowFetchRecord(cache.lastIndex()+1));
    while (row < cache.firstIndex())
        cache.prepend(slowFetchRecord(cache.firstIndex()-1));

    return cache.at(row);
}

Si la caché está llena, se eliminará el elemento situado en el extremo opuesto de la caché respecto al lugar donde se añada el nuevo elemento, ya sea al principio o al final.

Este uso puede optimizarse aún más utilizando la función ` insert()` en los casos en que la fila solicitada se encuentre muy alejada de los elementos actualmente almacenados en la caché. Si existe un espacio entre el punto en el que se inserta el nuevo elemento y los elementos actualmente almacenados en caché, primero se eliminan los elementos existentes en la caché para mantener la naturaleza contigua de la misma. Por lo tanto, es importante tener cierto cuidado al utilizar ` insert()` para evitar un vaciado no deseado de la caché.

El rango de índices válidos para la clase `QContiguousCache` va de 0 a `INT_MAX`. Llamar a ` prepend()` de tal forma que el primer índice sea menor que 0, o a ` append()` de tal forma que el último índice sea mayor que `INT_MAX`, puede provocar que los índices de la caché dejen de ser válidos. Cuando los índices de la caché no son válidos, es importante llamar a ` normalizeIndexes()` antes de llamar a cualquiera de las siguientes funciones: ` containsIndex()`, ` firstIndex()`, ` lastIndex()`, ` at()` o ` operator[]()`. Llamar a estas funciones cuando la caché tiene índices no válidos dará lugar a un comportamiento indefinido. Los índices se pueden comprobar utilizando ` areIndexesValid()`.

En la mayoría de los casos, los índices no superarán el rango de 0 a INT_MAX, por lo que no será necesario utilizar normalizeIndexes().

Consulte el ejemplo «Cache contigua ».

Documentación de las funciones miembro

[explicit] QContiguousCache::QContiguousCache(qsizetype capacity = 0)

Crea una caché con el capacity especificado.

Véase también setCapacity().

QContiguousCache::QContiguousCache(const QContiguousCache<T> &other)

Crea una copia de ` other`.

Esta operación tarda un tiempo constante, ya que QContiguousCache se comparte de forma implícita. Esto hace que devolver un QContiguousCache desde una función sea muy rápido. Si se modifica una instancia compartida, se copiará (copia al escribir), lo que lleva un tiempo lineal.

Véase también operator=().

QContiguousCache::~QContiguousCache()

Borra la caché.

void QContiguousCache::append(const T &value)

Inserta value al final de la caché. Si la caché ya está llena, se eliminará el elemento situado al principio de la misma.

Véase también prepend(), insert() y isFull().

bool QContiguousCache::areIndexesValid() const

Devuelve si los índices de los elementos almacenados en la caché son válidos. Los índices pueden dejar de ser válidos si se añaden elementos después de la posición de índice INT_MAX o antes de la posición de índice 0. Se espera que esto solo ocurra en usos de la caché contigua de tipo búfer circular de muy larga duración. Los índices pueden volver a ser válidos llamando a normalizeIndexes().

Véanse también normalizeIndexes(), append() y prepend().

const T &QContiguousCache::at(qsizetype i) const

Devuelve el elemento situado en la posición de índice i de la caché. i debe ser una posición de índice válida en la caché (es decir, firstIndex() <= i <= lastIndex()).

Los índices de la caché se refieren al número de posiciones que separa al elemento del primer elemento añadido a la caché. Es decir, una caché con una capacidad de 100, a la que se hayan añadido 150 elementos, tendrá un rango de índices válido comprendido entre 50 y 149. Esto permite insertar y recuperar elementos de la caché basándose en una lista teóricamente infinita

Véase también firstIndex(), lastIndex(), insert() y operator[]().

qsizetype QContiguousCache::available() const

Devuelve el número de elementos que se pueden añadir a la caché antes de que se llene.

Véase también size(), capacity() y isFull().

qsizetype QContiguousCache::capacity() const

Devuelve el número de elementos que puede almacenar la caché antes de llenarse. Cuando una caché contiene un número de elementos igual a su capacidad, al añadir nuevos elementos se eliminarán los que se encuentren más lejos del elemento añadido.

Véase también setCapacity() y size().

void QContiguousCache::clear()

Elimina todos los elementos de la caché. La capacidad no varía.

bool QContiguousCache::containsIndex(qsizetype i) const

Devuelve ` true ` si el rango de índices de la caché incluye el índice dado ` i`.

Véase también firstIndex() y lastIndex().

qsizetype QContiguousCache::count() const

Es lo mismo que « size()».

T &QContiguousCache::first()

Devuelve una referencia al primer elemento de la caché. Esta función da por hecho que la caché no está vacía.

Véase también last() y isEmpty().

const T &QContiguousCache::first() const

Esta es una función sobrecargada.

qsizetype QContiguousCache::firstIndex() const

Devuelve el primer índice válido de la caché. El índice no será válido si la caché está vacía.

Véase también capacity(), size() y lastIndex().

void QContiguousCache::insert(qsizetype i, const T &value)

Inserta el elemento value en la posición de índice i. Si la caché ya contiene un elemento en i, dicho valor se sustituye. Si i es uno mayor que lastIndex() o uno menor que firstIndex(), equivale a un append() o a un prepend().

Si el índice dado i no se encuentra dentro del rango actual de la caché ni es adyacente a los límites del rango de índices de la caché, primero se vacía la caché antes de insertar el elemento. En ese momento, la caché tendrá un tamaño de 1. Merece la pena esforzarse por insertar los elementos en un orden que comience adyacente al rango de índices actual de la caché.

El rango de índices válidos para la clase QContiguousCache va de 0 a INT_MAX. La inserción fuera de este rango tiene un comportamiento indefinido.

Véase también prepend(), append(), isFull(), firstIndex() y lastIndex().

bool QContiguousCache::isEmpty() const

Devuelve « true » si no hay elementos almacenados en la caché.

Véase también size() y capacity().

bool QContiguousCache::isFull() const

Devuelve « true » si el número de elementos almacenados en la caché es igual a la capacidad de la misma.

Véase también size() y capacity().

T &QContiguousCache::last()

Devuelve una referencia al último elemento de la caché. Esta función da por hecho que la caché no está vacía.

Véase también first() y isEmpty().

const T &QContiguousCache::last() const

Esta es una función sobrecargada.

qsizetype QContiguousCache::lastIndex() const

Devuelve el último índice válido de la caché. El índice no será válido si la caché está vacía.

Véase también capacity(), size() y firstIndex().

void QContiguousCache::normalizeIndexes()

Desplaza el primer índice y el último índice de la caché de tal forma que apunten a índices válidos. La función no modifica el contenido de la caché ni el orden de los elementos dentro de la misma.

Se proporciona para que se puedan corregir los desbordamientos de índice cuando se utiliza la caché como búfer circular.

QContiguousCache<int> cache(10);
cache.insert(INT_MAX, 1); // cache contains one value and has valid indexes, INT_MAX to INT_MAX
cache.append(2); // cache contains two values but does not have valid indexes.
cache.normalizeIndexes(); // cache has two values, 1 and 2.  New first index will be in the range of 0 to capacity().

Véanse también areIndexesValid(), append() y prepend().

void QContiguousCache::prepend(const T &value)

Inserta « value » al principio de la caché. Si la caché ya está llena, se eliminará el elemento situado al final de la misma.

Véase también append(), insert() y isFull().

void QContiguousCache::removeFirst()

Elimina el primer elemento de la caché. Esta función da por hecho que la caché no está vacía.

Véase también removeLast().

void QContiguousCache::removeLast()

Elimina el último elemento de la caché. Esta función da por hecho que la caché no está vacía.

Véase también removeFirst().

void QContiguousCache::setCapacity(qsizetype size)

Establece la capacidad de la caché en el valor dado size. Una caché puede contener un número de elementos igual a su capacidad. Al insertar, añadir al final o al principio elementos en la caché, si esta ya está llena, se eliminará el elemento más alejado del elemento añadido.

Si el valor de size es menor que el número actual de elementos de la caché, solo se conservarán los últimos size elementos de la caché.

Véanse también capacity() y isFull().

qsizetype QContiguousCache::size() const

Devuelve el número de elementos que contiene la caché.

Véase también capacity().

[noexcept] void QContiguousCache::swap(QContiguousCache<T> &other)

Intercambia esta caché con other. Esta operación es muy rápida y nunca falla.

T QContiguousCache::takeFirst()

Elimina el primer elemento de la caché y lo devuelve. Esta función da por hecho que la caché no está vacía.

Si no se utiliza el valor devuelto, la función ` removeFirst()` resulta más eficiente.

Véase también takeLast() y removeFirst().

T QContiguousCache::takeLast()

Elimina el último elemento de la caché y lo devuelve. Esta función da por hecho que la caché no está vacía.

Si no se utiliza el valor devuelto, la función removeLast() resulta más eficiente.

Véanse también takeFirst() y removeLast().

bool QContiguousCache::operator!=(const QContiguousCache<T> &other) const

Devuelve ` true ` si ` other ` no es igual a esta caché; en caso contrario, devuelve ` false`.

Se considera que dos cachés son iguales si contienen los mismos valores en los mismos índices. Esta función requiere que el tipo de valor implemente la interfaz operator==().

Véase también operator==().

[noexcept] QContiguousCache<T> &QContiguousCache::operator=(QContiguousCache<T> &&other)

Asigna « other » a esta instancia de « QContiguousCache ». . . . . . . . . . . . . . . . . . . . . . . . . .xml-ph-0001@

QContiguousCache<T> &QContiguousCache::operator=(const QContiguousCache<T> &other)

Asigna ` other ` a esta caché y devuelve una referencia a la misma.

bool QContiguousCache::operator==(const QContiguousCache<T> &other) const

Devuelve « true » si « other » es igual a esta caché; en caso contrario, devuelve « false ».

Se considera que dos cachés son iguales si contienen los mismos valores en los mismos índices. Esta función requiere que el tipo de valor implemente la interfaz operator==().

Véase también operator!=().

T &QContiguousCache::operator[](qsizetype i)

Devuelve el elemento situado en la posición de índice i como una referencia modificable. Si la caché no contiene ningún elemento en la posición de índice indicada i, primero insertará un elemento vacío en esa posición.

En la mayoría de los casos, es mejor utilizar at() o insert().

Nota: Esta sobrecarga no const del operador [] requiere que QContiguousCache realice una copia profunda. Utiliza at() para el acceso de solo lectura a un QContiguousCache no const.

Véase también insert() y at().

const T &QContiguousCache::operator[](qsizetype i) const

Igual que en (i).

Se trata de una función sobrecargada.

© 2026 The Qt Company Ltd. Documentation contributions included herein are the copyrights of their respective owners. The documentation provided herein is licensed under the terms of the GNU Free Documentation License version 1.3 as published by the Free Software Foundation. Qt and respective logos are trademarks of The Qt Company Ltd. in Finland and/or other countries worldwide. All other trademarks are property of their respective owners.