QHash Class
template <typename Key, typename T> class QHashLa clase QHash es una clase de plantilla que proporciona un diccionario basado en una tabla hash. Más información...
| Encabezado: | #include <QHash> |
| CMake: | find_package(Qt6 REQUIRED COMPONENTS Core) target_link_libraries(mytarget PRIVATE Qt6::Core) |
| qmake: | QT += core |
- Lista de todos los miembros, incluidos los miembros heredados
- Miembros obsoletos
- QHash forma parte de las clases compartidas implícitamente y de las clases contenedoras.
Nota: Todas las funciones de esta clase son reentrantes.
Comparaciones de QHash
| Categoría | Tipos comparables |
|---|---|
| igualdad | QHash |
Tipos públicos
(since 6.9) struct | TryEmplaceResult |
| class | const_iterator |
| class | iterator |
| class | key_iterator |
| ConstIterator | |
| Iterator | |
| const_key_value_iterator | |
| difference_type | |
| key_type | |
| key_value_iterator | |
| mapped_type | |
| size_type |
Funciones públicas
| QHash() | |
| QHash(std::initializer_list<std::pair<Key, T>> list) | |
| QHash(InputIterator begin, InputIterator end) | |
| QHash(const QHash<Key, T> &other) | |
| QHash(QHash<Key, T> &&other) | |
| ~QHash() | |
(since 6.4) auto | asKeyValueRange() && |
(since 6.4) auto | asKeyValueRange() & |
(since 6.4) auto | asKeyValueRange() const && |
(since 6.4) auto | asKeyValueRange() const & |
| QHash<Key, T>::iterator | begin() |
| QHash<Key, T>::const_iterator | begin() const |
| qsizetype | capacity() const |
| QHash<Key, T>::const_iterator | cbegin() const |
| QHash<Key, T>::const_iterator | cend() const |
| void | clear() |
| QHash<Key, T>::const_iterator | constBegin() const |
| QHash<Key, T>::const_iterator | constEnd() const |
| QHash<Key, T>::const_iterator | constFind(const Key &key) const |
| QHash<Key, T>::const_key_value_iterator | constKeyValueBegin() const |
| QHash<Key, T>::const_key_value_iterator | constKeyValueEnd() const |
| bool | contains(const Key &key) const |
| qsizetype | count(const Key &key) const |
| qsizetype | count() const |
| QHash<Key, T>::iterator | emplace(Key &&key, Args &&... args) |
| QHash<Key, T>::iterator | emplace(const Key &key, Args &&... args) |
| bool | empty() const |
| QHash<Key, T>::iterator | end() |
| QHash<Key, T>::const_iterator | end() const |
| QHash<Key, T>::iterator | erase(QHash<Key, T>::const_iterator pos) |
| QHash<Key, T>::iterator | find(const Key &key) |
| QHash<Key, T>::const_iterator | find(const Key &key) const |
| void | insert(const QHash<Key, T> &other) |
| QHash<Key, T>::iterator | insert(const Key &key, const T &value) |
(since 6.11) QHash<Key, T>::iterator | insert(Key &&key, T &&value) |
(since 6.11) QHash<Key, T>::iterator | insert(Key &&key, const T &value) |
(since 6.11) QHash<Key, T>::iterator | insert(const Key &key, T &&value) |
(since 6.9) QHash<Key, T>::TryEmplaceResult | insertOrAssign(K &&key, Value &&value) |
(since 6.9) QHash<Key, T>::TryEmplaceResult | insertOrAssign(Key &&key, Value &&value) |
(since 6.9) QHash<Key, T>::TryEmplaceResult | insertOrAssign(const Key &key, Value &&value) |
(since 6.9) std::pair<QHash<Key, T>::key_value_iterator, bool> | insert_or_assign(K &&key, Value &&value) |
(since 6.9) std::pair<QHash<Key, T>::key_value_iterator, bool> | insert_or_assign(Key &&key, Value &&value) |
(since 6.9) std::pair<QHash<Key, T>::key_value_iterator, bool> | insert_or_assign(const Key &key, Value &&value) |
(since 6.9) QHash<Key, T>::key_value_iterator | insert_or_assign(QHash<Key, T>::const_iterator hint, K &&key, Value &&value) |
(since 6.9) QHash<Key, T>::key_value_iterator | insert_or_assign(QHash<Key, T>::const_iterator hint, Key &&key, Value &&value) |
(since 6.9) QHash<Key, T>::key_value_iterator | insert_or_assign(QHash<Key, T>::const_iterator hint, const Key &key, Value &&value) |
| bool | isEmpty() const |
| Key | key(const T &value) const |
| Key | key(const T &value, const Key &defaultKey) const |
| QHash<Key, T>::key_iterator | keyBegin() const |
| QHash<Key, T>::key_iterator | keyEnd() const |
| QHash<Key, T>::key_value_iterator | keyValueBegin() |
| QHash<Key, T>::const_key_value_iterator | keyValueBegin() const |
| QHash<Key, T>::key_value_iterator | keyValueEnd() |
| QHash<Key, T>::const_key_value_iterator | keyValueEnd() const |
| QList<Key> | keys() const |
| QList<Key> | keys(const T &value) const |
| float | load_factor() const |
| bool | remove(const Key &key) |
(since 6.1) qsizetype | removeIf(Predicate pred) |
| void | reserve(qsizetype size) |
| qsizetype | size() const |
| void | squeeze() |
| void | swap(QHash<Key, T> &other) |
| T | take(const Key &key) |
(since 6.9) QHash<Key, T>::TryEmplaceResult | tryEmplace(K &&key, Args &&... args) |
(since 6.9) QHash<Key, T>::TryEmplaceResult | tryEmplace(Key &&key, Args &&... args) |
(since 6.9) QHash<Key, T>::TryEmplaceResult | tryEmplace(const Key &key, Args &&... args) |
(since 6.9) QHash<Key, T>::TryEmplaceResult | tryInsert(K &&key, const T &value) |
(since 6.9) QHash<Key, T>::TryEmplaceResult | tryInsert(const Key &key, const T &value) |
(since 6.9) std::pair<QHash<Key, T>::key_value_iterator, bool> | try_emplace(K &&key, Args &&... args) |
(since 6.9) std::pair<QHash<Key, T>::key_value_iterator, bool> | try_emplace(Key &&key, Args &&... args) |
(since 6.9) std::pair<QHash<Key, T>::key_value_iterator, bool> | try_emplace(const Key &key, Args &&... args) |
(since 6.9) QHash<Key, T>::key_value_iterator | try_emplace(QHash<Key, T>::const_iterator hint, K &&key, Args &&... args) |
(since 6.9) QHash<Key, T>::key_value_iterator | try_emplace(QHash<Key, T>::const_iterator hint, Key &&key, Args &&... args) |
(since 6.9) QHash<Key, T>::key_value_iterator | try_emplace(QHash<Key, T>::const_iterator hint, const Key &key, Args &&... args) |
| T | value(const Key &key) const |
| T | value(const Key &key, const T &defaultValue) const |
| QList<T> | values() const |
| QHash<Key, T> & | operator=(QHash<Key, T> &&other) |
| QHash<Key, T> & | operator=(const QHash<Key, T> &other) |
| T & | operator[](const Key &key) |
| const T | operator[](const Key &key) const |
Elementos no miembros relacionados
(since 6.1) qsizetype | erase_if(QHash<Key, T>&hash, Predicate pred) |
(since 6.5) size_t | qHash(Enum key, size_t seed = 0) |
| size_t | qHash(const QStringRef&key, size_t seed = 0) |
| size_t | qHash(const QMqttTopicFilter&filtro, size_t semilla = 0) |
| size_t | qHash(const QSslKeyingMaterial&key) |
| size_t | qHash(const QGeoCoordinate&coordinate, size_t seed = 0) |
(since 6.0) size_t | qHash(QByteArrayView clave, size_t semilla = 0) |
| size_t | qHash(const QMqttTopicName&name, size_t seed = 0) |
| size_t | qHash(QSslEllipticCurve clave, size_t semilla = 0) |
| size_t | qHash(uchar clave, size_t semilla = 0) |
| size_t | qHash(uint clave, size_t semilla = 0) |
| size_t | qHash(ulong clave, size_t semilla = 0) |
| size_t | qHash(ushort clave, size_t semilla = 0) |
(since 6.0) size_t | qHash(wchar_t clave, size_t semilla = 0) |
| size_t | qHash(QDate clave, size_t semilla = 0) |
| size_t | qHash(const QOcspResponse&key, size_t seed = 0) |
| size_t | qHash(QLatin1StringView clave, size_t semilla = 0) |
| size_t | qHash(const QSslCertificate&key, size_t seed = 0) |
(since 6.0) size_t | qHash(QPoint clave, size_t semilla = 0) |
| size_t | qHash(const QSslError&key, size_t seed = 0) |
| size_t | qHash(QTime clave, size_t semilla = 0) |
| size_t | qHash(const QSslKeyingMaterial&key, size_t seed) |
(since 6.9) size_t | qHash(T clave, size_t semilla) |
| size_t | qHash(char clave, size_t semilla = 0) |
(since 6.0) size_t | qHash(char16_t clave, size_t semilla = 0) |
(since 6.0) size_t | qHash(char32_t clave, size_t semilla = 0) |
(since 6.0) size_t | qHash(char8_t clave, size_t semilla = 0) |
| size_t | qHash(const QBitArray&key, size_t seed = 0) |
| size_t | qHash(const QByteArray&key, size_t seed = 0) |
| size_t | qHash(const QChar key, size_t seed = 0) |
| size_t | qHash(const QDateTime&key, size_t seed = 0) |
| size_t | qHash(const QHash<Key, T>&key, size_t seed = 0) |
| size_t | qHash(const QSet<T>&key, size_t seed = 0) |
| size_t | qHash(const QString&key, size_t seed = 0) |
(since 6.0) size_t | qHash(const QTypeRevision&key, size_t seed = 0) |
| size_t | qHash(const QUrl&key, size_t seed = 0) |
| size_t | qHash(const QVersionNumber&key, size_t seed = 0) |
| size_t | qHash(const T*key, size_t seed = 0) |
(since 6.12) size_t | qHash(const std::optional<T>&key, size_t seed = 0) |
| size_t | qHash(const std::pair<T1, T2>&key, size_t seed = 0) |
| size_t | qHash(double key, size_t seed = 0) |
| size_t | qHash(float clave, size_t semilla = 0) |
| size_t | qHash(int clave, size_t semilla = 0) |
| size_t | qHash(long clave, size_t semilla = 0) |
| size_t | qHash(long double clave, size_t semilla = 0) |
(since 6.8) size_t | qHash(qint128 clave, size_t semilla = 0) |
| size_t | qHash(qint64 clave, size_t semilla = 0) |
(since 6.8) size_t | qHash(quint128 clave, size_t semilla = 0) |
| size_t | qHash(quint64 clave, size_t semilla = 0) |
| size_t | qHash(short clave, size_t semilla = 0) |
| size_t | qHash(signed char clave, size_t semilla = 0) |
(since 6.0) size_t | qHash(std::nullptr_t clave, size_t semilla = 0) |
| size_t | qHashBits(const void*p, size_t len, size_t seed = 0) |
(since 6.0) size_t | qHashMulti(size_t seed, const T &... args) |
(since 6.0) size_t | qHashMultiCommutative(size_t seed, const T &... args) |
| size_t | qHashRange(InputIterator first, InputIterator last, size_t seed = 0) |
| size_t | qHashRangeCommutative(InputIterator first, InputIterator last, size_t seed = 0) |
| bool | operator!=(const QHash<Key, T>&lhs, const QHash<Key, T>&rhs) |
| QDataStream & | operator<<(QDataStream&out, const QHash<Key, T>&hash) |
| bool | operator==(const QHash<Key, T>&lhs, const QHash<Key, T>&rhs) |
| QDataStream & | operator>>(QDataStream&in, QHash<Key, T>&hash) |
Macros
(since 6.11) | QT_NO_SINGLE_ARGUMENT_QHASH_OVERLOAD |
Descripción detallada
QHash<KEY, T> es una de las clases de contenedores genéricos de Qt, donde Key es el tipo utilizado para las claves de búsqueda y T es el tipo de valor asignado. Almacena pares (clave, valor) y permite una búsqueda muy rápida del valor asociado a una clave.
QHash ofrece una funcionalidad muy similar a la de QMap. Las diferencias son:
- QHash ofrece búsquedas más rápidas que QMap. (Véase «Complejidad algorítmica» para más detalles).
- Al iterar sobre un ` QMap`, los elementos siempre se ordenan por clave. Con `QHash`, los elementos se ordenan de forma arbitraria.
- El tipo de clave de un ` QMap ` debe proporcionar el operador `<()`. El tipo de clave de un `QHash` debe proporcionar el operador `==()` y una función hash global denominada ` qHash()` (véase qHash).
A continuación se muestra un ejemplo de QHash con claves de tipo « QString » y valores de tipo « int »:
Para insertar un par (clave, valor) en el hash, puedes utilizar el operador []():
hash["one"] = 1;
hash["three"] = 3;
hash["seven"] = 7;Esto inserta los tres pares (clave, valor) siguientes en el QHash: («uno», 1), («tres», 3) y («siete», 7). Otra forma de insertar elementos en el hash es utilizar insert():
hash.insert("twelve", 12);Para buscar un valor, utiliza el operador []() o value():
int num1 = hash["thirteen"];
int num2 = hash.value("thirteen");Si no hay ningún elemento con la clave especificada en el hash, estas funciones devuelven un valor construido por defecto.
Si quieres comprobar si el hash contiene una clave concreta, utiliza contains():
int timeout = 30;
if (hash.contains("TIMEOUT"))
timeout = hash.value("TIMEOUT");También existe una sobrecarga de ` value()` que utiliza su segundo argumento como valor por defecto si no hay ningún elemento con la clave especificada:
int timeout = hash.value("TIMEOUT", 30);En general, recomendamos utilizar contains() y value() en lugar del operador []() para buscar una clave en un hash. El motivo es que el operador []() inserta de forma implícita un elemento en el hash si no existe ningún elemento con la misma clave (a menos que el hash sea const). Por ejemplo, el siguiente fragmento de código creará 1000 elementos en memoria:
// WRONG
QHash<int, QWidget *> hash;
//...
for (int i = 0; i < 1000; ++i) {
if (hash[i] == okButton)
cout << "Found button at index " << i << endl;
}Para evitar este problema, sustituye hash[i] por hash.value(i) en el código anterior.
Internamente, QHash utiliza una tabla hash para realizar búsquedas. Esta tabla hash crece automáticamente para proporcionar búsquedas rápidas sin desperdiciar demasiada memoria. Aún así, puedes controlar el tamaño de la tabla hash llamando a ` reserve()` si ya sabes aproximadamente cuántos elementos contendrá el QHash, pero esto no es necesario para obtener un buen rendimiento. También puedes llamar a capacity() para obtener el tamaño de la tabla hash.
QHash no se reducirá automáticamente si se eliminan elementos de la tabla. Para minimizar la memoria utilizada por la tabla hash, llama a squeeze().
Para recorrer todos los pares (clave, valor) almacenados en un QHash, utiliza asKeyValueRange():
for (const auto &[key, value] : std::as_const(hash).asKeyValueRange())
cout << qPrintable(key) << ": " << value << endl;Esta función devuelve un objeto de rango que se puede utilizar con enlaces estructurados. Para el control manual del iterador, también se pueden utilizar los iteradores tradicionales al estilo STL (QHash::const_iterator y QHash::iterator):
for (auto it = hash.cbegin(); it != hash.cend(); ++it)
cout << qPrintable(it.key()) << ": " << it.value() << endl;Para modificar valores, utiliza iteradores:
for (auto it = hash.begin(); it != hash.end(); ++it)
it.value() += 1;QHash también proporciona iteradores al estilo de Java (QHashIterator y QMutableHashIterator) para garantizar la compatibilidad.
QHash no está ordenado, por lo que no se puede dar por sentado que la secuencia de un iterador sea predecible. Si se requiere un orden por clave, utiliza un QMap.
Un QHash solo permite un valor por clave. Si se llama a insert() con una clave que ya existe en el QHash, se borra el valor anterior. Por ejemplo:
hash.insert("plenty", 100);
hash.insert("plenty", 2000);
// hash.value("plenty") == 2000Si necesitas almacenar varias entradas para la misma clave en la tabla hash, utiliza ` QMultiHash`.
Si solo necesitas extraer los valores de un hash (no las claves), también puedes utilizar un «for» basado en rangos:
Los elementos se pueden eliminar del hash de varias formas. Una de ellas es llamar a ` remove()`; esto eliminará cualquier elemento con la clave indicada. Otra forma es utilizar ` QMutableHashIterator::remove()`. Además, puedes borrar todo el hash utilizando ` clear()`.
Los tipos de datos de las claves y los valores de QHash deben ser tipos de datos asignables. No se puede, por ejemplo, almacenar un QWidget como valor; en su lugar, se debe almacenar un QWidget *.
La función hash
El tipo de clave de un QHash tiene requisitos adicionales, además de ser un tipo de datos asignable: debe proporcionar el operador ==(), y también debe existir una función de hash que devuelva un valor hash para un argumento del tipo de la clave.
La función hash calcula un valor numérico a partir de una clave. Puede utilizar cualquier algoritmo imaginable, siempre y cuando devuelva el mismo valor si se le proporciona el mismo argumento. En otras palabras, si se cumple que ` e1 == e2`, entonces también debe cumplirse que ` hash(e1) == hash(e2) `. Sin embargo, para obtener un buen rendimiento, la función hash debería intentar devolver valores hash diferentes para claves diferentes en la mayor medida posible.
Una función hash para un tipo de clave K puede proporcionarse de dos formas diferentes.
La primera forma consiste en definir una sobrecarga de ` qHash() ` en el espacio de nombres de ` K`. La función ` qHash() ` debe tener una de estas firmas:
size_t qHash(K key, size_t seed);
size_t qHash(const K &key, size_t seed);
size_t qHash(K key); // deprecated, do not use
size_t qHash(const K &key); // deprecated, do not useLas sobrecargas de dos argumentos aceptan un entero sin signo que debe utilizarse para inicializar el cálculo de la función hash. QHash proporciona esta semilla con el fin de evitar una familia de algorithmic complexity attacks.
Nota: En Qt 6 es posible definir una sobrecarga de qHash() que admita un solo argumento; sin embargo, esta funcionalidad está en desuso. A partir de Qt 7, será obligatorio utilizar una sobrecarga de dos argumentos. Si se definen tanto una sobrecarga de un argumento como otra de dos argumentos para un tipo de clave, QHash utilizará esta última (ten en cuenta que basta con definir una versión de dos argumentos y utilizar un valor por defecto para el parámetro de semilla). En Qt 6 es posible desactivar la compatibilidad con la sobrecarga de ` qHash ` de un solo argumento definiendo la macro ` QT_NO_SINGLE_ARGUMENT_QHASH_OVERLOAD `.
La segunda forma de proporcionar una función de hash es especializando la clase ` std::hash ` para el tipo de clave ` K` y proporcionando un operador de llamada a función adecuado para ella:
namespace std
{
template <> struct hash<K>
{
// seed is optional
size_t operator()(const K &key, size_t seed = 0) const;
};
}El argumento «seed» tiene el mismo significado que en « qHash() » y puede omitirse.
Esta segunda forma permite reutilizar la misma función hash entre QHash y los contenedores asociativos no ordenados de la biblioteca estándar de C++. Si para un tipo se proporcionan tanto una sobrecarga de ` qHash() ` como una especialización de ` std::hash `, se da preferencia a la sobrecarga de ` qHash() `.
A continuación se ofrece una lista parcial de los tipos de C++ y Qt que pueden servir como claves en un QHash: cualquier tipo entero (char, unsigned long, etc.), cualquier tipo de puntero, QChar, QString y QByteArray. Para todos ellos, el encabezado <QHash> define una función qHash() que calcula un valor hash adecuado. Muchas otras clases de Qt también declaran una sobrecarga de qHash para su tipo; consulta la documentación de cada clase.
Si desea utilizar otros tipos como clave, asegúrese de proporcionar el operador ==() y una implementación de hash.
La función de conveniencia qHashMulti() puede utilizarse para implementar qHash() para un tipo personalizado, en los casos en que normalmente se desee generar un valor hash a partir de varios campos:
Ejemplo:
#ifndef EMPLOYEE_H
#define EMPLOYEE_H
class Employee
{
public:
Employee() {}
Employee(const QString &name, QDate dateOfBirth);
QString name() const { return myName; }
QDate dateOfBirth() const { return myDateOfBirth; }
//...
private:
QString myName;
QDate myDateOfBirth;
};
inline bool operator==(const Employee &e1, const Employee &e2)
{
return e1.name() == e2.name()
&& e1.dateOfBirth() == e2.dateOfBirth();
}
inline size_t qHash(const Employee &key, size_t seed)
{
return qHashMulti(seed, key.name(), key.dateOfBirth());
}
#endif // EMPLOYEE_HEn el ejemplo anterior, hemos recurrido a la propia implementación de Qt de ` qHash()` para ` QString ` y ` QDate `, con el fin de obtener un valor hash para el nombre y la fecha de nacimiento del empleado, respectivamente.
Ten en cuenta que la implementación de las sobrecargas de ` qHash()` que ofrece Qt puede cambiar en cualquier momento. No debes dar por sentado que ` qHash()` dará los mismos resultados (para las mismas entradas) en diferentes versiones de Qt.
Ataques de complejidad algorítmica
Todas las tablas hash son vulnerables a una clase concreta de ataques de denegación de servicio, en los que el atacante calcula previamente y con precisión un conjunto de claves diferentes que van a ser hashadas en el mismo compartimento de una tabla hash (o que incluso tendrán el mismo valor hash). El objetivo del ataque es provocar el peor comportamiento algorítmico posible (O(n) en lugar de O(1) amortizado; véase «Complejidad algorítmica» para más detalles) cuando los datos se introducen en la tabla.
Para evitar este comportamiento en el peor de los casos, el cálculo del valor hash realizado por qHash() puede incrementarse con una semilla aleatoria, lo que anula el alcance del ataque. Esta semilla la genera automáticamente QHash una vez por proceso y, a continuación, QHash la pasa como segundo argumento de la sobrecarga de dos argumentos de la función qHash().
Esta aleatorización de QHash está habilitada por defecto. Aunque los programas nunca deberían depender de un orden concreto de QHash, puede haber situaciones en las que se necesite temporalmente un comportamiento determinista, por ejemplo, para la depuración o las pruebas de regresión. Para deshabilitar la aleatorización, define la variable de entorno QT_HASH_SEED con el valor 0. Como alternativa, puedes llamar a la función QHashSeed::setDeterministicGlobalSeed().
Véase también QHashIterator, QMutableHashIterator, QMap y QSet.
Documentación sobre tipos de miembros
QHash::ConstIterator
Sinónimo al estilo Qt de « QHash::const_iterator ».
QHash::Iterator
Sinónimo al estilo Qt de « QHash::iterator ».
QHash::const_key_value_iterator
La definición de tipo `QHash::const_key_value_iterator` proporciona un iterador `const` al estilo de la STL para ` QHash`.
QHash::const_key_value_iterator es, en esencia, lo mismo que QHash::const_iterator, con la diferencia de que el operador *() devuelve un par clave/valor en lugar de un valor.
Véase también ` QKeyValueIterator`.
[alias] QHash::difference_type
Definición de tipo para ptrdiff_t. Se proporciona para garantizar la compatibilidad con la STL.
[alias] QHash::key_type
Definición de tipo para «Key». Se proporciona para garantizar la compatibilidad con la STL.
QHash::key_value_iterator
La definición de tipo `QHash::key_value_iterator` proporciona un iterador al estilo STL para ` QHash`.
QHash::key_value_iterator es, en esencia, igual que QHash::iterator, con la diferencia de que el operador *() devuelve un par clave/valor en lugar de un valor.
Véase también QKeyValueIterator.
[alias] QHash::mapped_type
Definición de tipo para T. Se proporciona para garantizar la compatibilidad con la STL.
[alias] QHash::size_type
Definición de tipo para int. Se proporciona para garantizar la compatibilidad con la STL.
Documentación de las funciones miembro
[noexcept default] QHash::QHash()
Crea un hash vacío.
Véase también ` clear()`.
QHash::QHash(std::initializer_list<std::pair<Key, T>> list)
Crea un hash con una copia de cada uno de los elementos de la lista de inicialización list.
template <typename InputIterator> QHash::QHash(InputIterator begin, InputIterator end)
Crea un hash con una copia de cada uno de los elementos del rango del iterador [begin, end). O bien los elementos sobre los que itera el rango deben ser objetos con los miembros de datos first y second (como std::pair), convertibles a Key y a T, respectivamente; o bien los iteradores deben tener las funciones miembro key() y value(), que devuelvan una clave convertible a Key y un valor convertible a T, respectivamente.
[noexcept] QHash::QHash(const QHash<Key, T> &other)
Crea una copia de other.
Esta operación se realiza en tiempo constante, ya que QHash se comparte implícitamente. Esto hace que devolver un QHash 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=().
[noexcept] QHash::QHash(QHash<Key, T> &&other)
Move crea una instancia de QHash, haciendo que apunte al mismo objeto al que apuntaba other.
QHash::~QHash()
Elimina el hash. Las referencias a los valores del hash y todos los iteradores de este hash dejan de ser válidos.
[since 6.4] auto QHash::asKeyValueRange() &&
[since 6.4] auto QHash::asKeyValueRange() &
[since 6.4] auto QHash::asKeyValueRange() const &&
[since 6.4] auto QHash::asKeyValueRange() const &
Devuelve un objeto de rango que permite iterar sobre este hash como pares clave/valor. Por ejemplo, este objeto de rango se puede utilizar en un bucle «for» basado en rangos, en combinación con una declaración de enlace estructurado:
QHash<QString, int> hash;
hash.insert("January", 1);
hash.insert("February", 2);
// ...
hash.insert("December", 12);
for (auto [key, value] : hash.asKeyValueRange()) {
cout << qPrintable(key) << ": " << value << endl;
--value; // convert to JS month indexing
}Ten en cuenta que tanto la clave como el valor obtenidos de esta forma son referencias a los que se encuentran en el hash. Concretamente, modificar el valor alterará el propio hash.
Advertencia: Los iteradores o referenciasdevueltos deben considerarse invalidados la próxima vez que se llame a una función no const sobre el hash, o cuando se destruya el hash.
Estas funciones se introdujeron en Qt 6.4.
Véase también QKeyValueIterator.
QHash<Key, T>::iterator QHash::begin()
Devuelve un iterador de estilo STL que apunta al primer elemento del hash.
Advertencia: Los iteradores o referenciasdevueltos deben considerarse invalidados la próxima vez que se llame a una función no const sobre el hash, o cuando se destruya el hash.
Véase también constBegin() y end().
[noexcept] QHash<Key, T>::const_iterator QHash::begin() const
Advertencia: Los iteradores o referenciasdevueltos deben considerarse invalidados la próxima vez que se llame a una función no const sobre el hash, o cuando se destruya el hash.
Esta es una función sobrecargada.
[noexcept] qsizetype QHash::capacity() const
Devuelve el número de compartimentos de la tabla hash interna de QHash.
El único propósito de esta función es proporcionar un medio para ajustar con precisión el uso de memoria de ` QHash`. En general, rara vez necesitarás llamar a esta función. Si quieres saber cuántos elementos hay en el hash, llama a ` size()`.
Véanse también reserve() y squeeze().
[noexcept] QHash<Key, T>::const_iterator QHash::cbegin() const
Devuelve un iterador const al estilo STL que apunta al primer elemento del hash.
Advertencia: Los iteradores o referenciasdevueltos deben considerarse invalidados la próxima vez que se llame a una función no const sobre el hash, o cuando se destruya el hash.
Véase también begin() y cend().
[noexcept] QHash<Key, T>::const_iterator QHash::cend() const
Devuelve un iterador const al estilo STL que apunta al elemento imaginario situado después del último elemento del hash.
Advertencia: Los iteradores o referenciasdevueltos deben considerarse invalidados la próxima vez que se llame a una función no const sobre el hash, o cuando se destruya el hash.
Véase también cbegin() y end().
[noexcept(...)] void QHash::clear()
Elimina todos los elementos del hash y libera toda la memoria que este ocupa.
Nota: Esta función es «noexcept» cuando ` std::is_nothrow_destructible<Node>::value ` es ` true`.
Véase también remove().
[noexcept] QHash<Key, T>::const_iterator QHash::constBegin() const
Devuelve un iterador constante al estilo STL que apunta al primer elemento del hash.
Advertencia: Los iteradores o referenciasdevueltos deben considerarse invalidados la próxima vez que se llame a una función no const sobre el hash, o cuando se destruya el hash.
Véase también begin() y constEnd().
[noexcept] QHash<Key, T>::const_iterator QHash::constEnd() const
Devuelve un iterador const al estilo STL que apunta al elemento imaginario situado después del último elemento del hash.
Advertencia: Los iteradores o referenciasdevueltos deben considerarse invalidados la próxima vez que se llame a una función no const sobre el hash, o cuando se destruya el hash.
Véase también constBegin() y end().
[noexcept] QHash<Key, T>::const_iterator QHash::constFind(const Key &key) const
Devuelve un iterador que apunta al elemento con el key en el hash.
Si el hash no contiene ningún elemento con el key, la función devuelve constEnd().
Advertencia: Los iteradores o referenciasdevueltos deben considerarse invalidados la próxima vez que se llame a una función no const sobre el hash, o cuando se destruya el hash.
Véase también ` find()`.
[noexcept] QHash<Key, T>::const_key_value_iterator QHash::constKeyValueBegin() const
Devuelve un iterador const al estilo STL que apunta a la primera entrada del hash.
Advertencia: Los iteradores o referenciasdevueltos deben considerarse invalidados la próxima vez que se llame a una función no const sobre el hash, o cuando se destruya el hash.
Véase también ` keyValueBegin()`.
[noexcept] QHash<Key, T>::const_key_value_iterator QHash::constKeyValueEnd() const
Devuelve un iterador const al estilo STL que apunta a la entrada imaginaria situada después de la última entrada del hash.
Advertencia: Los iteradores o referenciasdevueltos deben considerarse invalidados la próxima vez que se llame a una función no const sobre el hash, o cuando se destruya el hash.
Véase también ` constKeyValueBegin()`.
[noexcept] bool QHash::contains(const Key &key) const
Devuelve « true » si el hash contiene un elemento con el valor « key »; en caso contrario, devuelve « false ».
Véase también count().
[noexcept] qsizetype QHash::count(const Key &key) const
Devuelve el número de elementos asociados a ` key`.
Véase también contains().
[noexcept] qsizetype QHash::count() const
Es lo mismo que ` size()`.
Esta es una función sobrecargada.
template <typename... Args> QHash<Key, T>::iterator QHash::emplace(Key &&key, Args &&... args)
template <typename... Args> QHash<Key, T>::iterator QHash::emplace(const Key &key, Args &&... args)
Inserta un nuevo elemento en el contenedor. Este nuevo elemento se crea in situ utilizando « args » como argumentos para su creación. Si el elemento ya existe en el contenedor, se sustituye.
Devuelve un iterador que apunta al nuevo elemento.
Advertencia: Los iteradores o referenciasdevueltos deben considerarse invalidados la próxima vez que se llame a una función no const sobre el hash, o cuando se destruya el hash.
[noexcept] bool QHash::empty() const
Esta función se proporciona para garantizar la compatibilidad con la STL. Es equivalente a ` isEmpty()`, y devuelve `true` si el hash está vacío; en caso contrario, devuelve ` false`.
[noexcept] QHash<Key, T>::iterator QHash::end()
Devuelve un iterador de estilo STL que apunta al elemento imaginario situado después del último elemento del hash.
Advertencia: Los iteradores o referenciasdevueltos deben considerarse inválidos la próxima vez que se llame a una función no const sobre el hash, o cuando se destruya el hash.
Véase también begin() y constEnd().
[noexcept] QHash<Key, T>::const_iterator QHash::end() const
Advertencia: Los iteradores o referenciasdevueltos deben considerarse invalidados la próxima vez que se llame a una función no const sobre el hash, o cuando se destruya el hash.
Esta es una función sobrecargada.
QHash<Key, T>::iterator QHash::erase(QHash<Key, T>::const_iterator pos)
Elimina del hash el par (clave, valor) asociado al iterador pos y devuelve un iterador al siguiente elemento del hash.
Esta función nunca provoca que QHash reorganice su estructura de datos interna. Esto significa que se puede invocar de forma segura mientras se itera y no afectará al orden de los elementos del hash. Por ejemplo:
QHash<QObject *, int> objectHash;
//...
QHash<QObject *, int>::iterator i = objectHash.find(obj);
while (i != objectHash.end() && i.key() == obj) {
if (i.value() == 0) {
i = objectHash.erase(i);
} else {
++i;
}
}Advertencia: Los iteradores o referenciasdevueltos deben considerarse invalidados la próxima vez que se llame a una función no const sobre el hash, o cuando se destruya el hash.
Véase también remove(), take() y find().
QHash<Key, T>::iterator QHash::find(const Key &key)
Devuelve un iterador que apunta al elemento del hash que contiene el key.
Si el hash no contiene ningún elemento con el key, la función devuelve end().
Si el hash contiene varios elementos con la clave « key », esta función devuelve un iterador que apunta al valor insertado más recientemente. Se puede acceder a los demás valores incrementando el iterador. Por ejemplo, aquí hay un fragmento de código que recorre todos los elementos con la misma clave:
QHash<QString, int> hash;
//...
QHash<QString, int>::const_iterator i = hash.find("HDR");
while (i != hash.end() && i.key() == "HDR") {
cout << i.value() << endl;
++i;
}Advertencia: Los iteradores o referenciasdevueltos deben considerarse invalidados la próxima vez que se llame a una función no const sobre el hash, o cuando se destruya el hash.
Véase también value() y values().
[noexcept] QHash<Key, T>::const_iterator QHash::find(const Key &key) const
Advertencia: Los iteradores o referenciasdevueltos deben considerarse invalidados la próxima vez que se llame a una función no const sobre el hash, o cuando se destruya el hash.
Esta es una función sobrecargada.
void QHash::insert(const QHash<Key, T> &other)
Inserta todos los elementos del hash other en este hash.
Si una clave es común a ambos hash, su valor se sustituirá por el valor almacenado en other.
QHash<Key, T>::iterator QHash::insert(const Key &key, const T &value)
Inserta un nuevo elemento con el key y un valor de value.
Si ya existe un elemento con la clave « key », el valor de dicho elemento se sustituye por « value ».
Al insertar un par clave/valor con una clave ya existente, se sustituye el valor existente.
Devuelve un iterador que apunta al elemento nuevo o actualizado.
Advertencia: Los iteradores o referenciasdevueltos deben considerarse invalidados la próxima vez que se llame a una función no const en el hash, o cuando se destruya el hash.
[since 6.11] QHash<Key, T>::iterator QHash::insert(Key &&key, T &&value)
[since 6.11] QHash<Key, T>::iterator QHash::insert(Key &&key, const T &value)
[since 6.11] QHash<Key, T>::iterator QHash::insert(const Key &key, T &&value)
Estas funciones se introdujeron en Qt 6.11.
[since 6.9] template <typename K, typename Value> requires if_heterogeneously_searchable<K> && if_key_constructible_from<K> QHash<Key, T>::TryEmplaceResult QHash::insertOrAssign(K &&key, Value &&value)
[since 6.9] template <typename Value> QHash<Key, T>::TryEmplaceResult QHash::insertOrAssign(Key &&key, Value &&value)
[since 6.9] template <typename Value> QHash<Key, T>::TryEmplaceResult QHash::insertOrAssign(const Key &key, Value &&value)
Intenta insertar un elemento con los valores key y value. Si ya existe un elemento con el valor key, su valor se sobrescribe con value.
Devuelve una instancia de ` TryEmplaceResult`, una estructura que contiene un ` iterator ` que apunta al elemento, y un valor booleano, ` inserted`, que indica si el elemento se ha creado de nuevo (true) o si ya existía anteriormente (false).
Estas funciones se introdujeron en Qt 6.9.
Véase también insert(), tryEmplace() y tryInsert().
[since 6.9] template <typename K, typename Value> requires if_heterogeneously_searchable<K> && if_key_constructible_from<K> std::pair<QHash<Key, T>::key_value_iterator, bool> QHash::insert_or_assign(K &&key, Value &&value)
[since 6.9] template <typename Value> std::pair<QHash<Key, T>::key_value_iterator, bool> QHash::insert_or_assign(Key &&key, Value &&value)
[since 6.9] template <typename Value> std::pair<QHash<Key, T>::key_value_iterator, bool> QHash::insert_or_assign(const Key &key, Value &&value)
Intenta insertar un elemento con los valores key y value. Si ya existe un elemento con key, su valor se sobrescribe con value.
Devuelve un tuple compuesto por un iterador que apunta al elemento y un valor booleano, que indica si el elemento se ha creado recientemente (true) o si ya existía anteriormente (false).
Estas funciones se proporcionan para garantizar la compatibilidad con la biblioteca estándar.
Estas funciones se introdujeron en Qt 6.9.
Véanse también insert(), tryEmplace(), tryInsert() y insertOrAssign().
[since 6.9] template <typename K, typename Value> requires if_heterogeneously_searchable<K> && if_key_constructible_from<K> QHash<Key, T>::key_value_iterator QHash::insert_or_assign(QHash<Key, T>::const_iterator hint, K &&key, Value &&value)
[since 6.9] template <typename Value> QHash<Key, T>::key_value_iterator QHash::insert_or_assign(QHash<Key, T>::const_iterator hint, Key &&key, Value &&value)
[since 6.9] template <typename Value> QHash<Key, T>::key_value_iterator QHash::insert_or_assign(QHash<Key, T>::const_iterator hint, const Key &key, Value &&value)
Intenta insertar un elemento con los valores key y value. Si ya existe un elemento con key, su valor se sobrescribe con value.
Devuelve un tuple compuesto por un iterador que apunta al elemento y un valor booleano, que indica si el elemento se ha creado de nuevo (true) o si ya existía anteriormente (false).
hint se ignora.
Estas funciones se proporcionan por motivos de compatibilidad con la biblioteca estándar.
Estas funciones se introdujeron en Qt 6.9.
Véanse también insert(), tryEmplace() y insertOrAssign().
[noexcept] bool QHash::isEmpty() const
Devuelve « true » si el hash no contiene ningún elemento; en caso contrario, devuelve «false».
Véase también size().
[noexcept] Key QHash::key(const T &value) const
[noexcept] Key QHash::key(const T &value, const Key &defaultKey) const
Devuelve la primera clave asociada a value. Si el hash no contiene ningún elemento asociado a value, devuelve defaultKey o una clave construida por defecto si no se ha proporcionado este parámetro.
Esta función puede ser lenta (tiempo lineal), ya que la estructura de datos interna de QHash está optimizada para una búsqueda rápida por clave, no por valor.
[noexcept] QHash<Key, T>::key_iterator QHash::keyBegin() const
Devuelve un iterador const al estilo STL que apunta a la primera clave del hash.
Advertencia: Los iteradores o referenciasdevueltos deben considerarse invalidados la próxima vez que se llame a una función no const sobre el hash, o cuando se destruya el hash.
Véase también ` keyEnd()`.
[noexcept] QHash<Key, T>::key_iterator QHash::keyEnd() const
Devuelve un iterador constante al estilo STL que apunta al elemento imaginario situado después de la última clave del hash.
Advertencia: Los iteradores o referenciasdevueltos deben considerarse invalidados la próxima vez que se llame a una función no const sobre el hash, o cuando se destruya el hash.
Véase también ` keyBegin()`.
QHash<Key, T>::key_value_iterator QHash::keyValueBegin()
Devuelve un iterador de estilo STL que apunta a la primera entrada del hash.
Advertencia: Los iteradores o referenciasdevueltos deben considerarse invalidados la próxima vez que se llame a una función no const sobre el hash, o cuando se destruya el hash.
Véase también ` keyValueEnd()`.
[noexcept] QHash<Key, T>::const_key_value_iterator QHash::keyValueBegin() const
Devuelve un iterador const al estilo STL que apunta a la primera entrada del hash.
Advertencia: Los iteradores o referenciasdevueltos deben considerarse invalidados la próxima vez que se llame a una función no const sobre el hash, o cuando el hash sea destruido.
Véase también keyValueEnd().
QHash<Key, T>::key_value_iterator QHash::keyValueEnd()
Devuelve un iterador de estilo STL que apunta a la entrada imaginaria situada después de la última entrada del hash.
Advertencia: Los iteradores o referenciasdevueltos deben considerarse invalidados la próxima vez que se llame a una función no const sobre el hash, o cuando se destruya el hash.
Véase también keyValueBegin().
[noexcept] QHash<Key, T>::const_key_value_iterator QHash::keyValueEnd() const
Devuelve un iterador constante al estilo STL que apunta a la entrada imaginaria situada después de la última entrada del hash.
Advertencia: Los iteradores o referenciasdevueltos deben considerarse invalidados la próxima vez que se llame a una función no const sobre el hash, o cuando se destruya el hash.
Véase también ` keyValueBegin()`.
QList<Key> QHash::keys() const
Devuelve una lista que contiene todas las claves del hash, en un orden arbitrario.
Se garantiza que el orden será el mismo que el utilizado por values().
Esta función crea una nueva lista en tiempo lineal. El consumo de tiempo y memoria que esto conlleva puede evitarse iterando desde keyBegin() hasta keyEnd().
Véanse también values() y key().
QList<Key> QHash::keys(const T &value) const
Devuelve una lista que contiene todas las claves asociadas al valor value, en un orden arbitrario.
Esta función puede ser lenta (tiempo lineal), ya que la estructura de datos interna de ` QHash` está optimizada para una búsqueda rápida por clave, no por valor.
Se trata de una función sobrecargada.
[noexcept] float QHash::load_factor() const
Devuelve el factor de carga actual de la tabla hash interna de QHash. Es equivalente a capacity()/size(). La implementación utilizada tratará de mantener el factor de carga entre 0,25 y 0,5. De este modo se evita que se produzcan demasiadas colisiones en la tabla hash, lo que degradaría el rendimiento.
Incluso con un factor de carga bajo, la implementación de la tabla hash tiene una sobrecarga de memoria muy reducida.
Este método existe exclusivamente con fines de diagnóstico y rara vez deberías tener que llamarlo tú mismo.
Véase también reserve() y squeeze().
bool QHash::remove(const Key &key)
Elimina del hash el elemento que tiene la clave « key ». Devuelve «true» si la clave existe en el hash y el elemento se ha eliminado; en caso contrario, devuelve «false».
Véase también clear() y take().
[since 6.1] template <typename Predicate> qsizetype QHash::removeIf(Predicate pred)
Elimina del hash todos los elementos para los que el predicado pred devuelve «true».
La función admite predicados que aceptan como argumento un valor de tipo ` QHash<Key, T>::iterator` o un valor de tipo ` std::pair<const Key &, T &>`.
Devuelve el número de elementos eliminados, si los hay.
Esta función se introdujo en Qt 6.1.
Véase también clear() y take().
void QHash::reserve(qsizetype size)
Garantiza que la tabla hash interna de ` QHash` disponga de espacio suficiente para almacenar al menos ` size ` elementos sin necesidad de ampliarla.
Esto implica que la tabla hash contendrá al menos 2 * size compartimentos para garantizar un buen rendimiento
Esta función resulta útil para código que necesita construir un hash de gran tamaño y desea evitar reasignaciones repetidas. Por ejemplo:
QHash<QString, int> hash;
hash.reserve(20000);
for (int i = 0; i < 20000; ++i)
hash.insert(keys[i], values[i]);Lo ideal es que size sea el número máximo de elementos que se espera que contenga el hash. QHash elegirá entonces el menor número posible de compartimentos que permita almacenar size elementos en la tabla sin tener que ampliar la tabla hash interna. Si size es una estimación a la baja, lo peor que puede pasar es que QHash sea un poco más lento.
En general, rara vez necesitarás llamar a esta función. La tabla hash interna de QHash se amplía automáticamente para ofrecer un buen rendimiento sin desperdiciar demasiada memoria.
Véase también squeeze() y capacity().
[noexcept] qsizetype QHash::size() const
Devuelve el número de elementos del hash.
Véase también isEmpty() y count().
void QHash::squeeze()
Reduce el tamaño de la tabla hash interna de QHash para ahorrar memoria.
El único propósito de esta función es proporcionar un medio para ajustar con precisión el uso de memoria de QHash. En general, rara vez será necesario llamar a esta función.
Véase también ` reserve()` y ` capacity()`.
[noexcept] void QHash::swap(QHash<Key, T> &other)
Intercambia este hash por other. Esta operación es muy rápida y nunca falla.
T QHash::take(const Key &key)
Elimina del hash el elemento con el identificador « key » y devuelve el valor asociado a él.
Si el elemento no existe en el hash, la función simplemente devuelve un valor construido por defecto.
Si no se utiliza el valor devuelto, la función ` remove()` resulta más eficiente.
Véase también remove().
[since 6.9] template <typename K, typename... Args> requires if_heterogeneously_searchable<K> && if_key_constructible_from<K> QHash<Key, T>::TryEmplaceResult QHash::tryEmplace(K &&key, Args &&... args)
[since 6.9] template <typename... Args> QHash<Key, T>::TryEmplaceResult QHash::tryEmplace(Key &&key, Args &&... args)
[since 6.9] template <typename... Args> QHash<Key, T>::TryEmplaceResult QHash::tryEmplace(const Key &key, Args &&... args)
Inserta un nuevo elemento con el ` key ` y un valor construido a partir de ` args`. Si ya existe un elemento con ` key `, no se realiza ninguna inserción.
Devuelve una instancia de ` TryEmplaceResult`, una estructura que contiene un ` iterator ` que apunta al elemento recién creado, o al elemento preexistente que impidió la inserción, y un valor booleano, ` inserted`, que indica si se ha producido la inserción.
Por ejemplo, esto se puede utilizar para evitar el patrón de comparar el tamaño antiguo con el nuevo o las búsquedas dobles. Donde antes habrías escrito código como:
QHash<int, MyType> hash;
// [...]
int myKey = getKey();
qsizetype oldSize = hash.size();
MyType &elem = hash[myKey];
if (oldSize != hash.size()) // Size changed: new element!
initialize(elem);
// [use elem...]Ahora puedes escribir en su lugar:
QHash<int, MyType> hash;
// [...]
int myKey = getKey();
auto result = hash.tryEmplace(myKey);
if (result.inserted) // New element!
initialize(*result.iterator);
// [use result.iterator...]Estas funciones se introdujeron en Qt 6.9.
Véanse también emplace(), tryInsert() y insertOrAssign().
[since 6.9] template <typename K> requires if_heterogeneously_searchable<K> && if_key_constructible_from<K> QHash<Key, T>::TryEmplaceResult QHash::tryInsert(K &&key, const T &value)
[since 6.9] QHash<Key, T>::TryEmplaceResult QHash::tryInsert(const Key &key, const T &value)
Inserta un nuevo elemento con el key y un valor de value. Si ya existe un elemento con key, no se realiza ninguna inserción.
Devuelve una instancia de ` TryEmplaceResult`, una estructura que contiene un ` iterator ` que apunta al elemento recién creado, o al elemento preexistente que impidió la inserción, y un valor booleano, ` inserted`, que indica si se ha producido la inserción.
Estas funciones se introdujeron en Qt 6.9.
Véanse también insert(), tryEmplace() y insertOrAssign().
[since 6.9] template <typename K, typename... Args> requires if_heterogeneously_searchable<K> && if_key_constructible_from<K> std::pair<QHash<Key, T>::key_value_iterator, bool> QHash::try_emplace(K &&key, Args &&... args)
[since 6.9] template <typename... Args> std::pair<QHash<Key, T>::key_value_iterator, bool> QHash::try_emplace(Key &&key, Args &&... args)
[since 6.9] template <typename... Args> std::pair<QHash<Key, T>::key_value_iterator, bool> QHash::try_emplace(const Key &key, Args &&... args)
Inserta un nuevo elemento con el key y un valor construido a partir de args. Si ya existe un elemento con key, no se lleva a cabo la inserción.
Devuelve un par formado por un iterador al elemento insertado (o al elemento que impidió la inserción) y un valor booleano que indica si se ha producido la inserción.
Estas funciones se proporcionan por motivos de compatibilidad con la biblioteca estándar.
Estas funciones se introdujeron en Qt 6.9.
Véase también emplace(), tryEmplace(), tryInsert() y insertOrAssign().
[since 6.9] template <typename K, typename... Args> requires if_heterogeneously_searchable<K> && if_key_constructible_from<K> QHash<Key, T>::key_value_iterator QHash::try_emplace(QHash<Key, T>::const_iterator hint, K &&key, Args &&... args)
[since 6.9] template <typename... Args> QHash<Key, T>::key_value_iterator QHash::try_emplace(QHash<Key, T>::const_iterator hint, Key &&key, Args &&... args)
[since 6.9] template <typename... Args> QHash<Key, T>::key_value_iterator QHash::try_emplace(QHash<Key, T>::const_iterator hint, const Key &key, Args &&... args)
Inserta un nuevo elemento con el identificador « key » y un valor construido a partir de « args ». Si ya existe un elemento con el identificador « key », no se lleva a cabo la inserción.
Devuelve el iterador del elemento insertado, o bien el del elemento que impidió la inserción.
hint Se ignora.
Estas funciones se proporcionan por motivos de compatibilidad con la biblioteca estándar.
Estas funciones se introdujeron en Qt 6.9.
Véase también emplace(), tryEmplace(), tryInsert() y insertOrAssign().
[noexcept] T QHash::value(const Key &key) const
[noexcept] T QHash::value(const Key &key, const T &defaultValue) const
Devuelve el valor asociado a ` key`.
Si el hash no contiene ningún elemento con el key, la función devuelve defaultValue, o un valor construido por defecto si no se ha proporcionado este parámetro.
QList<T> QHash::values() const
Devuelve una lista que contiene todos los valores del hash, en un orden arbitrario.
Se garantiza que el orden será el mismo que el utilizado por keys().
Esta función crea una nueva lista en tiempo lineal. El consumo de tiempo y memoria que ello conlleva puede evitarse iterando desde ` keyValueBegin()` hasta ` keyValueEnd()`.
Véanse también keys() y value().
[noexcept] QHash<Key, T> &QHash::operator=(QHash<Key, T> &&other)
Asigna « other » a esta instancia de « QHash ».
[noexcept] QHash<Key, T> &QHash::operator=(const QHash<Key, T> &other)
Asigna « other » a este hash y devuelve una referencia a dicho hash.
T &QHash::operator[](const Key &key)
Devuelve el valor asociado a key como una referencia modificable.
Si el hash no contiene ningún elemento con el key, la función inserta en el hash un valor construido por defecto con el key y devuelve una referencia al mismo.
Advertencia: Los iteradores o referenciasdevueltos deben considerarse invalidados la próxima vez que se llame a una función no const sobre el hash, o cuando se destruya el hash.
Véase también insert() y value().
[noexcept] const T QHash::operator[](const Key &key) const
Es lo mismo que ` value()`.
Esta es una función sobrecargada.
Elementos no miembros relacionados
[since 6.1] template <
typename Key,
typename T,
typename Predicate
>
qsizetype erase_if(QHash<Key, T> &hash, Predicate pred)
Elimina del hash hash todos los elementos para los que el predicado pred devuelve «true».
La función admite predicados que admiten como argumento un valor de tipo QHash<Key, T>::iterator o un valor de tipo std::pair<const Key &, T &>.
Devuelve el número de elementos eliminados, si los hay.
Esta función se introdujo en Qt 6.1.
[constexpr noexcept, since 6.5] template <typename Enum, std::enable_if_t<std::is_enum_v<Enum>, bool> = true> size_t qHash(Enum key, size_t seed = 0)
Devuelve el valor hash de key, utilizando seed como semilla para el cálculo.
Nota: Antes de Qt 6.5, las enumeraciones sin ámbito se basaban en las sobrecargas enteras de esta función debido a la conversión implícita a sus tipos enteros subyacentes. Para las enumeraciones con ámbito, había que implementar una sobrecarga por uno mismo. Esta sigue siendo la solución compatible con versiones anteriores para mantener la compatibilidad con versiones anteriores de Qt.
Esta función se introdujo en Qt 6.5.
[noexcept, since 6.0] size_t qHash(QByteArrayView key, size_t seed = 0)
Devuelve el valor hash de ` key`, utilizando ` seed ` como semilla para el cálculo.
Esta función se introdujo en Qt 6.0.
[constexpr noexcept] size_t qHash(uchar key, size_t seed = 0)
Devuelve el valor hash de key, utilizando seed como semilla para el cálculo.
[constexpr noexcept] size_t qHash(uint key, size_t seed = 0)
Devuelve el valor hash de key, utilizando seed como semilla para el cálculo.
[constexpr noexcept] size_t qHash(ulong key, size_t seed = 0)
Devuelve el valor hash de key, utilizando seed como semilla para el cálculo.
[constexpr noexcept] size_t qHash(ushort key, size_t seed = 0)
Devuelve el valor hash de key, utilizando seed como semilla para el cálculo.
[constexpr noexcept, since 6.0] size_t qHash(wchar_t key, size_t seed = 0)
Devuelve el valor hash de key, utilizando seed como semilla para el cálculo.
Esta función se introdujo en Qt 6.0.
[noexcept] size_t qHash(QDate key, size_t seed = 0)
Devuelve el valor hash de key, utilizando seed como semilla para el cálculo.
[noexcept] size_t qHash(QLatin1StringView key, size_t seed = 0)
Devuelve el valor hash de key, utilizando seed como semilla para el cálculo.
[noexcept, since 6.0] size_t qHash(QPoint key, size_t seed = 0)
Devuelve el valor hash de « key », utilizando « seed » como semilla para el cálculo.
Esta función se introdujo en Qt 6.0.
[noexcept] size_t qHash(QTime key, size_t seed = 0)
Devuelve el valor hash de key, utilizando seed como semilla para el cálculo.
[constexpr noexcept, since 6.9] template <typename T, std::enable_if_t<std::is_same_v<T, bool>, bool>> size_t qHash(T key, size_t seed)
Devuelve el valor hash de ` key`, utilizando ` seed ` como semilla para el cálculo.
Nota: Se trata de qHash(bool), restringida para aceptar únicamente argumentos de tipo bool, no argumentos de tipos que simplemente se conviertan a bool.
Nota: En las versiones de Qt anteriores a la 6.9, esta sobrecarga se proporcionaba de forma involuntaria mediante una función de plantilla adaptadora de qHash de 1 a 2 argumentos no documentada, con un comportamiento idéntico.
Esta función se introdujo en Qt 6.9.
[constexpr noexcept] size_t qHash(char key, size_t seed = 0)
Devuelve el valor hash de key, utilizando seed como semilla para el cálculo.
[constexpr noexcept, since 6.0] size_t qHash(char16_t key, size_t seed = 0)
Devuelve el valor hash de key, utilizando seed como semilla para el cálculo.
Esta función se introdujo en Qt 6.0.
[constexpr noexcept, since 6.0] size_t qHash(char32_t key, size_t seed = 0)
Devuelve el valor hash de key, utilizando seed como semilla para el cálculo.
Esta función se introdujo en Qt 6.0.
[constexpr noexcept, since 6.0] size_t qHash(char8_t key, size_t seed = 0)
Devuelve el valor hash de key, utilizando seed como semilla para el cálculo.
Esta función se introdujo en Qt 6.0.
[noexcept] size_t qHash(const QBitArray &key, size_t seed = 0)
Devuelve el valor hash de key, utilizando seed como semilla para el cálculo.
[noexcept] size_t qHash(const QByteArray &key, size_t seed = 0)
Devuelve el valor hash de key, utilizando seed como semilla para el cálculo.
[constexpr noexcept] size_t qHash(const QChar key, size_t seed = 0)
Devuelve el valor hash de key, utilizando seed como semilla para el cálculo.
size_t qHash(const QDateTime &key, size_t seed = 0)
Devuelve el valor hash de key, utilizando seed como semilla para el cálculo.
[noexcept(...)] template <typename Key, typename T> size_t qHash(const QHash<Key, T> &key, size_t seed = 0)
Devuelve el valor hash de key, utilizando seed como semilla para el cálculo.
Los tipos Key y T deben ser compatibles con qHash().
Nota: Esta función es «noexcept» cuando noexcept(qHash(std::declval<Key&>())) && noexcept(qHash(std::declval<T&>())) es true.
[noexcept(...)] template <typename T> size_t qHash(const QSet<T> &key, size_t seed = 0)
Devuelve el valor hash de « key », utilizando « seed » como semilla para el cálculo.
El tipo T debe ser compatible con qHash().
El valor hash es independiente del orden de los elementos en key; es decir, los conjuntos que contienen los mismos elementos generan el mismo valor hash.
Nota: Esta función es «noexcept» cuando ` noexcept(qHashRangeCommutative(key.begin(), key.end(), seed)) ` es ` true`.
[noexcept] size_t qHash(const QString &key, size_t seed = 0)
Devuelve el valor hash de key, utilizando seed como semilla para el cálculo.
[since 6.0] size_t qHash(const QTypeRevision &key, size_t seed = 0)
Devuelve el valor hash de key, utilizando seed como semilla para el cálculo.
Esta función se introdujo en Qt 6.0.
[noexcept] size_t qHash(const QUrl &key, size_t seed = 0)
Devuelve el valor hash de key, utilizando seed como semilla para el cálculo.
size_t qHash(const QVersionNumber &key, size_t seed = 0)
Devuelve el valor hash de key, utilizando seed como semilla para el cálculo.
[noexcept] template <typename T> size_t qHash(const T *key, size_t seed = 0)
Devuelve el valor hash de « key », utilizando « seed » como semilla para el cálculo.
[constexpr noexcept(...), since 6.12] template <typename T> size_t qHash(const std::optional<T> &key, size_t seed = 0)
Devuelve el valor hash de key, utilizando seed como semilla para el cálculo.
El tipo T debe ser compatible con qHash().
Esto equivale a
En concreto, si « key » está activado (has_value()), se garantiza que el valor hash de « key » sea el mismo que el de « key.value() », y que todos los opcionales desactivados (!has_value()), de cualquier tipo, generen el mismo valor hash.
Esta función se introdujo en Qt 6.12.
Nota: Esta función es «noexcept» cuando QHashPrivate::noexceptPairHash<T, T>() es true.
Véase también qHash (std::nullopt_t, size_t).
[noexcept(...)] template <typename T1, typename T2> size_t qHash(const std::pair<T1, T2> &key, size_t seed = 0)
Devuelve el valor hash de key, utilizando seed como semilla para el cálculo.
Los tipos ` T1 ` y ` T2 ` deben ser compatibles con `qHash()`.
Nota: Esta función es «noexcept» cuando QHashPrivate::noexceptPairHash<T1, T2>() es true.
[noexcept] size_t qHash(double key, size_t seed = 0)
Devuelve el valor hash de key, utilizando seed como semilla para el cálculo.
[noexcept] size_t qHash(float key, size_t seed = 0)
Devuelve el valor hash de key, utilizando seed como semilla para el cálculo.
[constexpr noexcept] size_t qHash(int key, size_t seed = 0)
Devuelve el valor hash de key, utilizando seed como semilla para el cálculo.
[constexpr noexcept] size_t qHash(long key, size_t seed = 0)
Devuelve el valor hash de key, utilizando seed como semilla para el cálculo.
[noexcept] size_t qHash(long double key, size_t seed = 0)
Devuelve el valor hash de key, utilizando seed como semilla para el cálculo.
[constexpr noexcept, since 6.8] size_t qHash(qint128 key, size_t seed = 0)
Devuelve el valor hash de key, utilizando seed como semilla para el cálculo.
Nota: Esta función solo está disponible en plataformas que admitan un tipo entero nativo de 128 bits.
Esta función se introdujo en Qt 6.8.
[constexpr noexcept] size_t qHash(qint64 key, size_t seed = 0)
Devuelve el valor hash de key, utilizando seed como semilla para el cálculo.
[constexpr noexcept, since 6.8] size_t qHash(quint128 key, size_t seed = 0)
Devuelve el valor hash de key, utilizando seed como semilla para el cálculo.
Nota: Esta función solo está disponible en plataformas que admitan un tipo entero nativo de 128 bits.
Esta función se introdujo en Qt 6.8.
[constexpr noexcept] size_t qHash(quint64 key, size_t seed = 0)
Devuelve el valor hash de key, utilizando seed como semilla para el cálculo.
[constexpr noexcept] size_t qHash(short key, size_t seed = 0)
Devuelve el valor hash de key, utilizando seed como semilla para el cálculo.
[constexpr noexcept] size_t qHash(signed char key, size_t seed = 0)
Devuelve el valor hash de « key », utilizando « seed » como semilla para el cálculo.
[constexpr noexcept, since 6.0] size_t qHash(std::nullptr_t key, size_t seed = 0)
Devuelve el valor hash de « key », utilizando « seed » como semilla para el cálculo.
Esta función se introdujo en Qt 6.0.
[noexcept] size_t qHashBits(const void *p, size_t len, size_t seed = 0)
Devuelve el valor hash del bloque de memoria de tamaño len al que apunta p, utilizando seed como semilla para el cálculo.
Utiliza esta función únicamente para implementar ` qHash()` para tus propios tipos personalizados. Por ejemplo, así es como podrías implementar una sobrecarga de ` qHash()` para `std::vector<int>`:
inline size_t qHash(const std::vector<int> &key, size_t seed = 0)
{
if (key.empty())
return seed;
else
return qHashBits(&key.front(), key.size() * sizeof(int), seed);
}Esto aprovecha el hecho de que std::vector distribuye sus datos de forma contigua. Si no fuera así, o si el tipo contenido tuviera relleno, deberías utilizar qHashRange() en su lugar.
Cabe reiterar que la implementación de `qHashBits()` —al igual que las sobrecargas de ` qHash()` que ofrece Qt— puede cambiar en cualquier momento. No debes dar por sentado que `qHashBits()` dará los mismos resultados (para las mismas entradas) en diferentes versiones de Qt.
Véanse también qHashRange() y qHashRangeCommutative().
[constexpr noexcept(...), since 6.0] template <typename... T> size_t qHashMulti(size_t seed, const T &... args)
Devuelve el valor hash de ` args`, utilizando ` seed ` como semilla para el cálculo, mediante la aplicación sucesiva de ` qHash()` a cada elemento y la combinación de los valores hash en uno solo.
Ten en cuenta que el orden de los argumentos es importante. Si el orden no importa, utiliza en su lugar qHashMultiCommutative(). Si estás aplicando el hash a memoria sin procesar, utiliza qHashBits(); si estás aplicando el hash a un rango, utiliza qHashRange().
Esta función se proporciona para facilitar la implementación de ` qHash()` para tus propios tipos personalizados. Por ejemplo, así es como podrías implementar una sobrecarga de ` qHash()` para una clase ` Employee`:
#ifndef EMPLOYEE_H
#define EMPLOYEE_H
class Employee
{
public:
Employee() {}
Employee(const QString &name, QDate dateOfBirth);
QString name() const { return myName; }
QDate dateOfBirth() const { return myDateOfBirth; }
//...
private:
QString myName;
QDate myDateOfBirth;
};
inline bool operator==(const Employee &e1, const Employee &e2)
{
return e1.name() == e2.name()
&& e1.dateOfBirth() == e2.dateOfBirth();
}
inline size_t qHash(const Employee &key, size_t seed)
{
return qHashMulti(seed, key.name(), key.dateOfBirth());
}
#endif // EMPLOYEE_HEsta función se introdujo en Qt 6.0.
Nota: Esta función es «noexcept» cuando std::conjunction_v<QtPrivate::QNothrowHashable<T>...> es true.
Véase también « qHashMultiCommutative » y « qHashRange ».
[constexpr noexcept(...), since 6.0] template <typename... T> size_t qHashMultiCommutative(size_t seed, const T &... args)
Devuelve el valor hash de args, utilizando seed como semilla para el cálculo, mediante la aplicación sucesiva de qHash() a cada elemento y la combinación de los valores hash en uno único.
El orden de los argumentos no tiene importancia. Si el orden sí importa, utiliza qHashMulti() en su lugar, ya que puede producir un hash de mejor calidad. Si estás aplicando el hash a memoria sin procesar, utiliza qHashBits(); si estás aplicando el hash a un rango, utiliza qHashRange().
Esta función se proporciona para facilitar la implementación de qHash() para tus propios tipos personalizados.
Esta función se introdujo en Qt 6.0.
Nota: Esta función es «noexcept» cuando std::conjunction_v<QtPrivate::QNothrowHashable<T>...> es true.
Véase también « qHashMulti » y « qHashRange ».
[noexcept(...)] template <typename InputIterator> size_t qHashRange(InputIterator first, InputIterator last, size_t seed = 0)
Devuelve el valor hash del intervalo [first,last), utilizando seed como semilla para el cálculo, mediante la aplicación sucesiva de qHash() a cada elemento y la combinación de los valores hash en uno solo.
El valor devuelto por esta función depende del orden de los elementos del intervalo. Esto significa que
{0, 1, 2}y
{1, 2, 0}se hash a valores diferentes. Si el orden no importa, por ejemplo en el caso de las tablas hash, utiliza en su lugar qHashRangeCommutative(). Si estás aplicando el hash a memoria sin procesar, utiliza qHashBits().
Utiliza esta función únicamente para implementar qHash() para tus propios tipos personalizados. Por ejemplo, así es como podrías implementar una sobrecarga de qHash() para std::vector<int>:
inline size_t qHash(const std::vector<int> &key, size_t seed = 0)
{
return qHashRange(key.begin(), key.end(), seed);
}Cabe reiterar que la implementación de `qHashRange()` —al igual que las sobrecargas de ` qHash()` que ofrece Qt— puede cambiar en cualquier momento. No debes dar por sentado que `qHashRange()` dará los mismos resultados (para las mismas entradas) en diferentes versiones de Qt, aunque ` qHash()` para el tipo de elemento sí lo hiciera.
Nota: Esta función es «noexcept» cuando noexcept(qHash(*first, 0)) es true.
Véanse también qHashBits() y qHashRangeCommutative().
[noexcept(...)] template <typename InputIterator> size_t qHashRangeCommutative(InputIterator first, InputIterator last, size_t seed = 0)
Devuelve el valor hash del rango [first,last), utilizando seed como semilla para el cálculo, mediante la aplicación sucesiva de qHash() a cada elemento y la combinación de los valores hash en uno solo.
El valor devuelto por esta función no depende del orden de los elementos del intervalo. Esto significa que
{0, 1, 2}y
{1, 2, 0}generan los mismos valores. Si el orden es importante, por ejemplo, en el caso de vectores y matrices, utiliza en su lugar qHashRange(). Si estás aplicando el hash a memoria sin procesar, utiliza qHashBits().
Utiliza esta función únicamente para implementar qHash() para tus propios tipos personalizados. Por ejemplo, así es como podrías implementar una sobrecarga de qHash() para std::unordered_set<int>:
inline size_t qHash(const std::unordered_set<int> &key, size_t seed = 0)
{
return qHashRangeCommutative(key.begin(), key.end(), seed);
}Cabe reiterar que la implementación de qHashRangeCommutative() —al igual que las sobrecargas de qHash() que ofrece Qt— puede cambiar en cualquier momento. No debes dar por sentado que qHashRangeCommutative() dará los mismos resultados (para las mismas entradas) en diferentes versiones de Qt XML, aunque sí lo hiciera qHash() para el tipo de elemento.
Nota: Esta función es «noexcept» cuando noexcept(qHash(*first, 0)) es true.
Véanse también qHashBits() y qHashRange().
[noexcept] bool operator!=(const QHash<Key, T> &lhs, const QHash<Key, T> &rhs)
Devuelve « true » si el hash de « lhs » no es igual al hash de « rhs »; en caso contrario, devuelve « false ».
Se considera que dos hash son iguales si contienen los mismos pares (clave, valor).
Esta función requiere que el tipo de valor implemente operator==().
Véase también operator==().
template <typename Key, typename T> QDataStream &operator<<(QDataStream &out, const QHash<Key, T> &hash)
Escribe el hash hash en el flujo out.
Esta función requiere que los tipos de clave y valor implementen operator<<().
Véase también «Serialización detipos de datos de Qt».
[noexcept] bool operator==(const QHash<Key, T> &lhs, const QHash<Key, T> &rhs)
Devuelve « true » si el hash de « lhs » es igual al hash de « rhs »; en caso contrario, devuelve « false ».
Se considera que dos hash son iguales si contienen los mismos pares (clave, valor).
Esta función requiere que el tipo de valor implemente operator==().
Véase también operator!=().
template <typename Key, typename T> QDataStream &operator>>(QDataStream &in, QHash<Key, T> &hash)
Lee un hash del flujo « in » y lo guarda en « hash ».
Esta función requiere que los tipos de clave y valor implementen ` operator>>()`.
Véase también «Serialización detipos de datos de Qt».
Documentación de macros
[since 6.11] QT_NO_SINGLE_ARGUMENT_QHASH_OVERLOAD
Al definir esta macro se desactiva la compatibilidad con las sobrecargas de ` qHash ` que solo admiten un argumento; en otras palabras, con las sobrecargas de ` qHash ` que no admiten también una semilla. La compatibilidad con las sobrecargas de un solo argumento de ` qHash ` está obsoleta y se eliminará en Qt 7.
Esta macro se introdujo en Qt 6.11.
Véase también qHash.
© 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.