Clases contenedor
Introducción
La biblioteca Qt proporciona un conjunto de clases contenedoras de uso general basadas en plantillas. Estas clases se pueden utilizar para almacenar elementos de un tipo específico. Por ejemplo, si necesitas una matriz redimensionable de objetos ` QString`, utiliza ` QList<QString>`.
Estas clases de contenedores están diseñadas para ser más ligeras, seguras y fáciles de usar que los contenedores de la STL. Si no estás familiarizado con la STL o prefieres hacer las cosas «al estilo Qt», puedes utilizar estas clases en lugar de las de la STL.
Las clases de contenedores se comparten de forma implícita, son reentrantes y están optimizadas para ofrecer velocidad, un bajo consumo de memoria y una expansión mínima del código en línea, lo que da como resultado ejecutables más pequeños. Además, son seguras para subprocesos en situaciones en las que todos los subprocesos que acceden a ellas las utilizan como contenedores de solo lectura.
Los contenedores proporcionan iteradores para su recorrido. Los iteradores al estilo STL son los más eficientes y pueden utilizarse junto con los de Qt XML y los de la STL generic algorithms. Se proporcionan iteradores al estilo Java para garantizar la compatibilidad con versiones anteriores.
Nota: Desde Qt 5.14, hay constructores de rango disponibles para la mayoría de las clases de contenedores. QMultiMap es una excepción notable. Se recomienda su uso para sustituir a los diversos métodos «from» y «to» obsoletos de Qt 5. Por ejemplo:
QList<int> list = {1, 2, 3, 4, 4, 5};
QSet<int> set(list.cbegin(), list.cend());
/*
Will generate a QSet containing 1, 2, 3, 4, 5.
*/Las clases de contenedores
Qt proporciona los siguientes contenedores secuenciales: QList, QStack y QQueue. Para la mayoría de las aplicaciones, QList es el mejor tipo que se puede utilizar. Permite añadir elementos con gran rapidez. Si realmente necesitas una lista enlazada, utiliza std::list. QStack y QQueue son clases de conveniencia que proporcionan semántica LIFO y FIFO.
Qt también proporciona estos contenedores asociativos: QMap, QMultiMap, QHash, QMultiHash y QSet. Los contenedores «Multi» admiten cómodamente varios valores asociados a una única clave. Los contenedores «Hash» proporcionan una búsqueda más rápida mediante el uso de una función hash en lugar de una búsqueda binaria en un conjunto ordenado.
Como casos especiales, las clases QCache y QContiguousCache permiten una búsqueda eficiente mediante hash de objetos en un espacio de almacenamiento de caché limitado.
| Clase | Resumen |
|---|---|
| QList<T> | Esta es, con diferencia, la clase contenedora más utilizada. Almacena una lista de valores de un tipo determinado (T) a los que se puede acceder mediante un índice. Internamente, almacena una matriz de valores de un tipo determinado en posiciones adyacentes en la memoria. La inserción al principio o en medio de una lista puede resultar bastante lenta, ya que puede suponer que haya que desplazar una gran cantidad de elementos una posición en la memoria. |
| QVarLengthArray<T, Prealloc> | Esto proporciona una matriz de longitud variable de bajo nivel. Se puede utilizar en lugar de QList en aquellos casos en los que la velocidad sea especialmente importante. |
| QStack<T> | Se trata de una subclase de conveniencia de ` QList ` que proporciona la semántica «último en entrar, primero en salir» (LIFO). Añade las siguientes funciones a las ya presentes en ` QList`: ` push()`, ` pop()` y ` top()`. |
| QQueue<T> | Se trata de una subclase de conveniencia de QList que proporciona la semántica «primero en entrar, primero en salir» (FIFO). Añade las siguientes funciones a las ya presentes en QList: enqueue(), dequeue() y head(). |
| QSet<T> | Esto proporciona un conjunto matemático de valor único con búsquedas rápidas. |
| QMap<Key, T> | Proporciona un diccionario (matriz asociativa) que asocia claves de tipo Key a valores de tipo T. Normalmente, cada clave está asociada a un único valor. QMap almacena sus datos en orden de Key; si el orden no importa, QHash es una alternativa más rápida. |
| QMultiMap<Key, T> | Esto proporciona un diccionario, como QMap, salvo que permite insertar varias claves equivalentes. |
| QHash<Key, T> | Tiene prácticamente la misma API que QMap, pero ofrece búsquedas significativamente más rápidas. QHash almacena sus datos en un orden arbitrario. |
| QMultiHash<Key, T> | Proporciona un diccionario basado en una tabla hash, como QHash, salvo que permite insertar varias claves equivalentes. |
Los contenedores se pueden anidar. Por ejemplo, es perfectamente posible utilizar un QMap<QString, QList<int>>, donde el tipo de clave es QString y el tipo de valor QList<int>.
Los contenedores se definen en archivos de cabecera individuales con el mismo nombre que el contenedor (por ejemplo, <QList>). Por comodidad, los contenedores se declaran por adelantado en <QtContainerFwd>.
Los valores almacenados en los distintos contenedores pueden ser de cualquier tipo de datos asignable. Para cumplir este requisito, un tipo debe proporcionar un constructor de copia y un operador de asignación. Para algunas operaciones también se requiere un constructor por defecto. Esto abarca la mayoría de los tipos de datos que probablemente querrás almacenar en un contenedor, incluidos los tipos básicos como int y double, los tipos de puntero y los tipos de datos de Qt como QString, QDate y QTime, pero no abarca QObject ni ninguna subclase de QObject (QWidget, QDialog, QTimer, etc.). Si intentas instanciar un ` QList` <QWidget>, el compilador te indicará que el constructor de copia y los operadores de asignación de ` QWidget` están deshabilitados. Si deseas almacenar este tipo de objetos en un contenedor, guárdalos como punteros, por ejemplo, como ` QList` <QWidget *>.
A continuación se muestra un ejemplo de tipo de datos personalizado que cumple el requisito de ser un tipo de datos asignable:
class Employee
{
public:
Employee() {}
Employee(const Employee &other);
Employee &operator=(const Employee &other);
private:
QString myName;
QDate myDateOfBirth;
};Si no se proporciona un constructor de copia ni un operador de asignación, C++ ofrece una implementación por defecto que realiza una copia miembro por miembro. En el ejemplo anterior, eso habría sido suficiente. Además, si no se proporciona ningún constructor, C++ proporciona un constructor por defecto que inicializa sus miembros utilizando constructores por defecto. Aunque no proporciona ningún constructor explícito ni operador de asignación, el siguiente tipo de datos se puede almacenar en un contenedor:
Algunos contenedores tienen requisitos adicionales respecto a los tipos de datos que pueden almacenar. Por ejemplo, el tipo «Key» de un contenedor « QMap<Key, T>» debe proporcionar « operator<() ». Dichos requisitos especiales se documentan en la descripción detallada de la clase. En algunos casos, funciones específicas tienen requisitos especiales; estos se describen para cada función en particular. El compilador siempre generará un error si no se cumple un requisito.
Los contenedores de Qt proporcionan los operadores <<() y >>() para que se puedan leer y escribir fácilmente utilizando un ` QDataStream`. Esto significa que los tipos de datos almacenados en el contenedor también deben admitir los operadores <<() y >>(). Proporcionar dicha compatibilidad es sencillo; así es como podríamos hacerlo para la estructura `Movie` anterior:
QDataStream &operator<<(QDataStream &out, const Movie &movie)
{
out << (quint32)movie.id << movie.title
<< movie.releaseDate;
return out;
}
QDataStream &operator>>(QDataStream &in, Movie &movie)
{
quint32 id;
QDate date;
in >> id >> movie.title >> date;
movie.id = (int)id;
movie.releaseDate = date;
return in;
}La documentación de ciertas funciones de las clases de contenedores hace referencia a valores construidos por defecto; por ejemplo, ` QList ` inicializa automáticamente sus elementos con valores construidos por defecto, y ` QMap::value()` devuelve un valor construido por defecto si la clave especificada no está en el mapa. Para la mayoría de los tipos de valor, esto significa simplemente que se crea un valor utilizando el constructor por defecto (por ejemplo, una cadena vacía para QString). Sin embargo, para los tipos primitivos como int y double, así como para los tipos de puntero, el lenguaje C++ no especifica ninguna inicialización; en esos casos, los contenedores de Qt inicializan automáticamente el valor a 0.
Iteración sobre contenedores
Bucle «for» basado en rangos
El ` for ` basado en rangos debería utilizarse preferentemente para contenedores:
Ten en cuenta que, al utilizar un contenedor de Qt en un contexto no const, el uso compartido implícito puede provocar una separación no deseada del contenedor. Para evitarlo, utiliza ` std::as_const()`:
En el caso de los contenedores asociativos, esto recorrerá los valores en bucle.
Basado en índices
En el caso de los contenedores secuenciales que almacenan sus elementos de forma contigua en la memoria (por ejemplo, QList), se puede utilizar la iteración basada en índices:
QList<QString> list = {"A", "B", "C", "D"};
for (qsizetype i = 0; i < list.size(); ++i) {
const auto &item = list.at(i);
//...
}Las clases de iteradores
Los iteradores proporcionan un medio uniforme para acceder a los elementos de un contenedor. Las clases de contenedores de Qt ofrecen dos tipos de iteradores: los iteradores al estilo STL y los iteradores al estilo Java. Los iteradores de ambos tipos quedan invalidados cuando se modifican los datos del contenedor o se desvinculan de las copias compartidas implícitamente debido a la llamada a una función miembro no const.
Iteradores al estilo STL
Los iteradores de estilo STL están disponibles desde el lanzamiento de Qt 2.0. Son compatibles con la biblioteca « generic algorithms » de Qt y STL, y están optimizados para la velocidad.
Para cada clase de contenedor, existen dos tipos de iteradores al estilo STL: uno que proporciona acceso de solo lectura y otro que proporciona acceso de lectura y escritura. Se deben utilizar los iteradores de solo lectura siempre que sea posible, ya que son más rápidos que los de lectura y escritura.
| Contenedores | Iterador de solo lectura | Iterador de lectura y escritura |
|---|---|---|
| QList<T>, QStack<T>, QQueue<T> | QList<T>::const_iterator | QList<T>::iterator |
| QSet<T> | QSet<T>::const_iterator | QSet<T>::iterator |
| QMap<Key, T>, QMultiMap<Key, T> | QMap<Key, T>::const_iterator | QMap<Key, T>::iterator |
| QHash<Key, T>, QMultiHash<Key, T> | QHash<Key, T>::const_iterator | QHash<Key, T>::iterator |
La API de los iteradores de la STL se basa en los punteros de un array. Por ejemplo, el operador « ++ » hace avanzar al iterador al siguiente elemento, y el operador « * » devuelve el elemento al que apunta el iterador. De hecho, en el caso de QList y QStack, que almacenan sus elementos en posiciones adyacentes de la memoria, el tipo iterator no es más que un typedef para T *, y el tipo const_iterator no es más que un typedef para const T *.
En este análisis, nos centraremos en QList y QMap. Los tipos de iterador para QSet tienen exactamente la misma interfaz que los iteradores de QList; del mismo modo, los tipos de iterador para QHash tienen la misma interfaz que los iteradores de QMap.
A continuación se muestra un bucle típico para recorrer todos los elementos de un QList<QString> en orden y convertirlos a minúsculas:
QList<QString> list = {"A", "B", "C", "D"};
for (auto i = list.begin(), end = list.end(); i != end; ++i)
*i = (*i).toLower();Los iteradores al estilo STL apuntan directamente a los elementos. La función begin() de un contenedor devuelve un iterador que apunta al primer elemento del contenedor. La función end() de un contenedor devuelve un iterador que apunta al elemento imaginario situado una posición más allá del último elemento del contenedor. end() marca una posición no válida; nunca debe desreferenciarse. Se suele utilizar en la condición de salida de un bucle. Si la lista está vacía, begin() es igual a end(), por lo que nunca se ejecuta el bucle.
El siguiente diagrama muestra las posiciones válidas del iterador, indicadas con flechas rojas, para una lista que contiene cuatro elementos:
La iteración hacia atrás con un iterador de estilo STL se realiza mediante iteradores inversos:
QList<QString> list = {"A", "B", "C", "D"};
for (auto i = list.rbegin(), rend = list.rend(); i != rend; ++i)
*i = i->toLower();En los fragmentos de código anteriores, hemos utilizado el operador unario « * » para recuperar el elemento (de tipo « QString ») almacenado en una determinada posición del iterador y, a continuación, hemos llamado a « QString::toLower()» sobre él.
Para el acceso de solo lectura, puedes utilizar `const_iterator`, ` cbegin()` y ` cend()`. Por ejemplo:
for (auto i = list.cbegin(), end = list.cend(); i != end;++i)
qDebug() << *i;La siguiente tabla resume la API de los iteradores al estilo STL:
| Expresión | Comportamiento |
|---|---|
*i | Devuelve el elemento actual |
++i | Avanza el iterador al elemento siguiente |
i += n | Avanza el iterador un n s elementos |
--i | Retrocede el iterador un elemento |
i -= n | Retrocede el iterador un número de elementos igual a ` n ` |
i - j | Devuelve el número de elementos entre los iteradores « i » y j |
Los operadores « ++ » y « -- » están disponibles tanto como operadores prefijos (++i, --i) como posfijos (i++, i--). Las versiones prefijas modifican los iteradores y devuelven una referencia al iterador modificado; las versiones posfijas toman una copia del iterador antes de modificarlo y devuelven dicha copia. En expresiones en las que se ignora el valor de retorno, recomendamos utilizar los operadores prefijos (++i, --i), ya que son ligeramente más rápidos.
Para los tipos de iterador no const, el valor de retorno del operador unario * puede utilizarse en el lado izquierdo del operador de asignación.
En el caso de QMap y QHash, el operador * devuelve el componente de valor de un elemento. Si desea recuperar la clave, llame a key() en el iterador. Por simetría, los tipos de iterador también proporcionan una función value() para recuperar el valor. Por ejemplo, así es como imprimiríamos todos los elementos de un QMap en la consola:
QMap<int, int> map;
//...
for (auto i = map.cbegin(), end = map.cend(); i != end;++i)
qDebug() << i.key() << ':' << i.value();Gracias al uso compartido implícito, a una función le resulta muy económico devolver un contenedor por valor. La API de Qt contiene docenas de funciones que devuelven un ` QList ` o un ` QStringList ` por valor (por ejemplo, ` QSplitter::sizes()`). Si quieres recorrer estos contenedores utilizando un iterador de la STL, siempre debes hacer una copia del contenedor y recorrerla. Por ejemplo:
// RIGHT
const QList<int> sizes = splitter->sizes();
for (auto i = sizes.begin(), end = sizes.end(); i != end; ++i)
{/*...*/}
// WRONG
for (auto i = splitter->sizes().begin();
i != splitter->sizes().end(); ++i)
{/*...*/}Este problema no se produce con las funciones que devuelven una referencia const o no const a un contenedor.
Problema del iterador de uso compartido implícito
El uso compartido implícito tiene otra consecuencia en los iteradores de estilo STL: debes evitar copiar un contenedor mientras haya iteradores activos en él. Los iteradores apuntan a una estructura interna y, si copias un contenedor, debes tener mucho cuidado con tus iteradores. Por ejemplo:
QList<int> a, b;
a.resize(100000); // make a big list filled with 0.
QList<int>::iterator i = a.begin();
// WRONG way of using the iterator i:
b = a;
/*
Now we should be careful with iterator i since it will point to shared data
If we do *i = 4 then we would change the shared instance (both vectors)
The behavior differs from STL containers. Avoid doing such things in Qt.
*/
a[0] = 5;
/*
Container a is now detached from the shared data,
and even though i was an iterator from the container a, it now works as an iterator in b.
Here the situation is that (*i) == 0.
*/
b.clear(); // Now the iterator i is completely invalid.
int j = *i; // Undefined behavior!
/*
The data from b (which i pointed to) is gone.
This would be well-defined with STL containers (and (*i) == 5),
but with QList this is likely to crash.
*/El ejemplo anterior solo muestra un problema con ` QList`, pero el problema se da en todos los contenedores de Qt con uso compartido implícito.
Iteradores al estilo Java
Los iteradores al estilo Java se basan en las clases de iteradores de Java. En el código nuevo se deben preferir los iteradores al estilo STL.
Comparación entre los contenedores de Qt y los contenedores estándar
| Contenedor de Qt | Contenedor estándar más similar |
|---|---|
| QList<T> | Similar a std::vector<T> QList y QVector se unificaron en Qt 6. Ambos utilizan el modelo de datos de QVector. QVector es ahora un alias de QList. Esto significa que QList no está implementado como una lista enlazada, por lo que, si necesitas operaciones de inserción, eliminación, adición al final o al principio en tiempo constante, te recomendamos que utilices |
| QVarLengthArray<T, Prealloc> | Se asemeja a una mezcla de std::array<T> y std::vector<T>. Por motivos de rendimiento, QVarLengthArray reside en la pila a menos que se cambie su tamaño. Al cambiar su tamaño, pasa automáticamente a utilizar el montón. |
| QStack<T> | Similar a std::stack<T>, hereda de QList. |
| QQueue<T> | Al igual que std::queue<T>, hereda de QList. |
| QSet<T> | Similar a std::unordered_set<T>. Internamente, QSet se implementa con un QHash. |
| QMap<Key, T> | Similar a std::map<Key, T>. |
| QMultiMap<Key, T> | Similar a std::multimap<Key, T>. |
| QHash<Key, T> | Muy similar a std::unordered_map<Key, T>. |
| QMultiHash<Key, T> | Muy similar a std::unordered_multimap<Key, T>. |
Contenedores de Qt y algoritmos de std
Puedes utilizar los contenedores de Qt con las funciones de #include <algorithm>.
QList<int> list = {2, 3, 1};
std::sort(list.begin(), list.end());
/*
Sort the list, now contains { 1, 2, 3 }
*/
std::reverse(list.begin(), list.end());
/*
Reverse the list, now contains { 3, 2, 1 }
*/
int even_elements =
std::count_if(list.begin(), list.end(), [](int element) { return (element % 2 == 0); });
/*
Count how many elements that are even numbers, 1
*/Algoritmos para contenedores de Qt
Qt también proporciona algoritmos genéricos adicionales en <QtAlgorithms> que funcionan con cualquier contenedor compatible con iteradores de estilo STL, como qJoin() para unir elementos de un contenedor en un único valor, y qDeleteAll() para invocar operator delete en todos los elementos de un contenedor o en un rango determinado.
Otras clases similares a contenedores
Qt incluye otras clases de plantilla que se asemejan a los contenedores en algunos aspectos. Estas clases no proporcionan iteradores y no pueden utilizarse con la palabra clave « foreach ».
- QCache<Key, T> proporciona una caché para almacenar objetos de un tipo determinado T asociados a claves de tipo Key.
- QContiguousCache<T> ofrece una forma eficaz de almacenar en caché datos a los que normalmente se accede de forma contigua.
Otros tipos que no son plantillas y que compiten con los contenedores de plantillas de Qt son QBitArray, QByteArray, QString y QStringList.
Complejidad algorítmica
La complejidad algorítmica se refiere a la rapidez (o lentitud) con la que se ejecuta cada función a medida que aumenta el número de elementos del contenedor. Por ejemplo, insertar un elemento en medio de una `std::list` es una operación extremadamente rápida, independientemente del número de elementos almacenados en la lista. Por otro lado, insertar un elemento en medio de una ` QList ` puede resultar muy costoso si la ` QList ` contiene muchos elementos, ya que la mitad de los elementos deben desplazarse una posición en la memoria.
Para describir la complejidad algorítmica, utilizamos la siguiente terminología, basada en la notación «gran Oh»:
- Tiempo constante: O(1). Se dice que una función se ejecuta en tiempo constante si requiere la misma cantidad de tiempo independientemente del número de elementos que haya en el contenedor. Un ejemplo es QList::push_back().
- Tiempo logarítmico: O(log n). Una función que se ejecuta en tiempo logarítmico es aquella cuyo tiempo de ejecución es proporcional al logaritmo del número de elementos del contenedor. Un ejemplo es el algoritmo de búsqueda binaria.
- Tiempo lineal: O(n). Una función que se ejecuta en tiempo lineal lo hará en un tiempo directamente proporcional al número de elementos almacenados en el contenedor. Un ejemplo es QList::insert().
- Tiempo lineal-logarítmico: O(n log n). Una función que se ejecuta en tiempo lineal-logarítmico es asintóticamente más lenta que una función de tiempo lineal, pero más rápida que una función de tiempo cuadrático.
- Tiempo cuadrático: O(n²). Una función de tiempo cuadrático se ejecuta en un tiempo proporcional al cuadrado del número de elementos almacenados en el contenedor.
La siguiente tabla resume la complejidad algorítmica del contenedor secuencial QList<T>:
| Búsqueda por índice | Inserción | Inserción al principio | Añadido al final | |
|---|---|---|---|---|
| QList<T> | O(1) | O(n) | O(n) | Amort. O(1) |
En la tabla, «Amort.» significa «comportamiento amortizado». Por ejemplo, «Amort. O(1)» significa que, si se llama a la función solo una vez, es posible que se obtenga un comportamiento de O(n), pero si se llama varias veces (por ejemplo, n veces), el comportamiento medio será de O(1).
La siguiente tabla resume la complejidad algorítmica de los contenedores asociativos y los conjuntos de Qt:
| Búsqueda de clave | Inserción | |||
|---|---|---|---|---|
| Media | Peor caso | Promedio | Peor caso | |
| QMap<Clave, T> | O(log n) | O(log n) | O(log n) | O(log n) |
| QMultiMap<Clave, T> | O(log n) | O(log n) | O(log n) | O(log n) |
| QHash<Clave, T> | Amort. O(1) | O(n) | Amort. O(1) | O(n) |
| QSet<Clave> | Amort. O(1) | O(n) | Amort. O(1) | O(n) |
Con QList, QHash y QSet, el rendimiento de la inserción de elementos al final de la lista tiene una complejidad amortizada de O(log n). Se puede reducir a O(1) llamando a QList::reserve(), QHash::reserve() o QSet::reserve() con el número esperado de elementos antes de insertarlos. En la siguiente sección se trata este tema con mayor profundidad.
Optimizaciones para tipos primitivos y reubicables
Los contenedores de Qt pueden utilizar rutas de código optimizadas si los elementos almacenados son reubicables o incluso primitivos. Sin embargo, no siempre es posible detectar si los tipos son primitivos o reubicables. Puede declarar que sus tipos sean primitivos o reubicables utilizando la macro ` Q_DECLARE_TYPEINFO ` con el indicador `Q_PRIMITIVE_TYPE` o el indicador `Q_RELOCATABLE_TYPE`. Consulte la documentación de ` Q_DECLARE_TYPEINFO ` para obtener más detalles y ejemplos de uso.
Si no se utiliza Q_DECLARE_TYPEINFO, Qt utilizará std::is_trivial_v<T> para identificar los tipos primitivos y requerirá tanto std::is_trivially_copyable_v<T> como std::is_trivially_destructible_v<T> para identificar los tipos reubicables. Esta es siempre una opción segura, aunque quizá el rendimiento no sea óptimo.
Estrategias de crecimiento
QList<T>, QString y QByteArray almacenan sus elementos de forma contigua en la memoria; QHash<Key, T> mantiene una tabla hash cuyo tamaño es proporcional al número de elementos del hash. Para evitar tener que reasignar los datos cada vez que se añade un elemento al final del contenedor, estas clases suelen asignar más memoria de la necesaria.
Consideremos el siguiente código, que crea un ` QString ` a partir de otro ` QString`:
QString onlyLetters(const QString &in)
{
QString out;
for (qsizetype j = 0; j < in.size(); ++j) {
if (in.at(j).isLetter())
out += in.at(j);
}
return out;
}Creamos la cadena out de forma dinámica añadiendo un carácter cada vez. Supongamos que añadimos 15 000 caracteres a la cadena « QString ». Entonces, se producen las siguientes 11 reasignaciones (de un total de 15 000 posibles) cuando « QString » se queda sin espacio: 8, 24, 56, 120, 248, 504, 1016, 2040, 4088, 8184, 16 376. Al final, la cadena QString tiene asignados 16 376 caracteres Unicode, de los cuales 15 000 están ocupados.
Los valores anteriores pueden parecer un poco extraños, pero hay un principio rector. Se avanza duplicando el tamaño cada vez. Más concretamente, se avanza a la siguiente potencia de dos, menos 16 bytes. 16 bytes corresponden a ocho caracteres, ya que QString utiliza UTF-16 internamente.
QByteArray utiliza el mismo algoritmo que QString, pero 16 bytes corresponden a 16 caracteres.
QList<T> también utiliza ese algoritmo, pero 16 bytes corresponden a 16/sizeof(T) elementos.
QHash<Key, T> es un caso totalmente diferente. La tabla hash interna de QHash crece en potencias de dos, y cada vez que crece, los elementos se reubican en un nuevo compartimento, calculado como qHash(clave) % QHash::capacity() (el número de compartimentos). Esta observación se aplica también a QSet<T> y QCache<Key, T>.
Para la mayoría de las aplicaciones, el algoritmo de crecimiento predeterminado que proporciona Qt es suficiente. Si necesitas un mayor control, QList<T>, QHash<KEY, T>, QSet<T>, QString y QByteArray ofrecen un conjunto de tres funciones que te permiten comprobar y especificar cuánta memoria se debe utilizar para almacenar los elementos:
- capacity() devuelve el número de elementos para los que se ha asignado memoria (en el caso de QHash y QSet, el número de compartimentos de la tabla hash).
- reserve(size) preasigna explícitamente memoria para size elementos.
- squeeze() libera toda la memoria que no sea necesaria para almacenar los elementos.
Si sabes aproximadamente cuántos elementos vas a almacenar en un contenedor, puedes empezar llamando a reserve(), y cuando hayas terminado de rellenar el contenedor, puedes llamar a squeeze() para liberar la memoria preasignada sobrante.
© 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.