Класс QHash

Класс QHash — шаблонный класс, предоставляющий словарь на основе хеш-таблицы. Подробнее...

• Список всех членов, включая унаследованные

Примечание: Все функции в этом классе являются многопоточными.

Открытые типы

Открытые функции

Связанные нечлены

Подробное описание

QHash<Key, T> — один из универсальных классов контейнеров Qt. Он хранит пары (ключ, значение) и обеспечивает очень быстрый поиск значения, связанного с ключом.

QHash предоставляет функциональность, очень похожую на QMap. Различия:

• QHash обеспечивает более быстрый поиск, чем QMap. (См. Сложность алгоритмов для получения подробностей.)
• При итерации по QMap элементы всегда упорядочиваются по ключу. В QHash элементы упорядочены произвольно.
• Тип ключа QMap должен предоставлять оператор <(). Тип ключа QHash должен предоставлять оператор ==() и глобальную функцию хеширования, называемую qHash() (см. qHash).

Вот пример QHash с ключами QString и значениями int:

QHash<QString, int> hash;

Чтобы вставить пару (ключ, значение) в хеш-таблицу, можно использовать оператор[]():

hash["one"] = 1;
hash["three"] = 3;
hash["seven"] = 7;

Это вставляет следующие три пары (ключ, значение) в QHash: ("one", 1), ("three", 3) и ("seven", 7). Другой способ вставки элементов в хеш-таблицу — использование insert():

hash.insert("twelve", 12);

Чтобы найти значение, используйте оператор[]() или value():

int num1 = hash["thirteen"];
int num2 = hash.value("thirteen");

Если в хеш-таблице нет элемента с указанным ключом, эти функции возвращают значение по умолчанию.

Если вы хотите проверить, содержит ли хеш-таблица определённый ключ, используйте contains():

int timeout = 30;
if (hash.contains("TIMEOUT"))
    timeout = hash.value("TIMEOUT");

Также существует перегрузка value(), которая использует свой второй аргумент в качестве значения по умолчанию, если нет элемента с указанным ключом:

int timeout = hash.value("TIMEOUT", 30);

В общем случае рекомендуется использовать contains() и value() для поиска ключа в хеш-таблице вместо оператора[]. Причина в том, что оператор[]() безмолвно вставляет элемент в хеш-таблицу, если нет элемента с тем же ключом (если хеш-таблица не является константной). Например, следующий фрагмент кода создаст 1000 элементов в памяти:

// WRONG
QHash<int, QWidget *> hash;
...
for (int i = 0; i < 1000; ++i) {
    if (hash[i] == okButton)
        cout << "Found button at index " << i << Qt::endl;
}

Чтобы избежать этой проблемы, замените hash[i] на hash.value(i) в коде выше.

Внутренне QHash использует хеш-таблицу для выполнения поиска. Эта хеш-таблица автоматически увеличивается, чтобы обеспечить быстрый поиск, не тратя слишком много памяти. Вы по-прежнему можете контролировать размер хеш-таблицы, вызвав reserve(), если вы уже примерно знаете, сколько элементов будет содержать QHash, но это не обязательно для получения хорошей производительности. Вы также можете вызвать capacity(), чтобы получить размер хеш-таблицы.

QHash не будет автоматически уменьшаться, если элементы удаляются из таблицы. Чтобы минимизировать используемую память хеша, вызовите squeeze().

Если вы хотите перебрать все пары (ключ, значение), хранящиеся в QHash, вы можете использовать итератор. QHash предоставляет итераторы в стиле Java (QHashIterator и QMutableHashIterator) и итераторы в стиле STL (QHash::const_iterator и QHash::iterator). Вот как перебрать QHash<QString, int> с помощью итератора в стиле Java:

QHashIterator<QString, int> i(hash);
while (i.hasNext()) {
    i.next();
    cout << i.key() << ": " << i.value() << Qt::endl;
}

Вот тот же код, но с итератором в стиле STL:

QHash<QString, int>::const_iterator i = hash.constBegin();
while (i != hash.constEnd()) {
    cout << i.key() << ": " << i.value() << Qt::endl;
    ++i;
}

QHash неупорядочен, поэтому последовательность итератора непредсказуема. Если требуется упорядочение по ключу, используйте QMap.

QHash позволяет иметь только одно значение на ключ. Если вы вызываете insert() с ключом, который уже существует в QHash, предыдущее значение удаляется. Например:

hash.insert("plenty", 100);
hash.insert("plenty", 2000);
// hash.value("plenty") == 2000

Если вам нужно хранить несколько записей для одного и того же ключа в хеш-таблице, используйте QMultiHash.

Если вам нужно только извлечь значения из хеша (не ключи), вы также можете использовать foreach:

QHash<QString, int> hash;
...
foreach (int value, hash)
    cout << value << Qt::endl;

Элементы можно удалить из хеша несколькими способами. Один способ — вызвать remove(); это удалит любой элемент с заданным ключом. Другой способ — использовать QMutableHashIterator::remove(). Кроме того, вы можете очистить весь хеш с помощью clear().

Тип данных ключа и значения QHash должны быть переменными типами. Например, вы не можете хранить QWidget как значение; вместо этого храните QWidget *.

Функция хеширования

Тип ключа QHash имеет дополнительные требования помимо того, что это переменный тип данных: он должен предоставлять оператор ==(), и также должна быть функция хеширования, которая возвращает значение хеша для аргумента типа ключа.

Функция хеширования вычисляет числовое значение на основе ключа. Она может использовать любой алгоритм, но при этом она всегда должна возвращать одно и то же значение для одного и того же аргумента. Другими словами, если e1 == e2, то hash(e1) == hash(e2) также должно выполняться. Однако для обеспечения хорошей производительности функция хеширования должна стремиться возвращать разные значения хеша для разных ключей в максимальной степени.

Функция хеширования для типа ключа K может быть реализована двумя способами.

Первый способ — определение перегрузки qHash() в пространстве имен K. Функция qHash() должна иметь одну из следующих сигнатур:

size_t qHash(K key);
size_t qHash(const K &key);

size_t qHash(K key, size_t seed);
size_t qHash(const K &key, size_t seed);

Перегрузки с двумя аргументами принимают целое беззнаковое число, которое должно использоваться для инициализации вычисления функции хеширования. Это семя предоставляется QHash для предотвращения атак с использованием сложности алгоритма.. Если определены как перегрузки с одним, так и с двумя аргументами, QHash использует перегрузку с двумя аргументами (вы можете просто определить перегрузку с двумя аргументами и использовать значение по умолчанию для параметра семя).

Второй способ предоставления функции хеширования — специализация класса std::hash для типа ключа K, и предоставление для него подходящего оператора вызова функции:

namespace std {
template <> struct hash<K>
{
    // seed is optional
    size_t operator()(const K &key, size_t seed = 0) const;
};
}

Аргумент семя имеет то же значение, что и для qHash(), и его можно опустить.

Этот второй способ позволяет повторно использовать одну и ту же функцию хеширования между QHash и контейнерами неупорядоченных ассоциативных данных стандартной библиотеки C++. Если для типа определены как перегрузка qHash() , так и специализация std::hash, то перегрузка qHash() будет предпочтительнее.

Вот неполный список типов C++ и Qt, которые могут использоваться в качестве ключей в QHash: любой целочисленный тип (char, unsigned long и т. д.), любой указатель, QChar, QString и QByteArray. Для всех этих типов заголовочный файл <QHash> определяет функцию qHash(), которая вычисляет подходящее значение хеша. Многие другие классы Qt также объявляют перегрузку qHash для своего типа; обратитесь к документации каждого класса.

Если вы хотите использовать другие типы в качестве ключей, убедитесь, что вы предоставили оператор ==() и реализацию хеширования.

Функция-удобство qHashMulti() может использоваться для реализации qHash() для пользовательского типа, где обычно требуется вычисление значения хеша из нескольких полей:

Пример:

#ifndef EMPLOYEE_H
#define EMPLOYEE_H

class Employee
{
public:
    Employee() {}
    Employee(const QString &name, QDate dateOfBirth);
    ...

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_H

В примере выше мы полагались на собственную реализацию Qt функции qHash() для QString и QDate для получения значения хеша для имени сотрудника и даты рождения соответственно.

Обратите внимание, что реализация перегрузок qHash(), предлагаемых Qt, может меняться в любое время. Вы не должны полагаться на то, что qHash() будет давать одинаковые результаты (для одних и тех же входных данных) в разных версиях Qt.

Атаки на сложность алгоритма

Все хеш-таблицы уязвимы для определенного класса атак с отказом в обслуживании, при которых злоумышленник тщательно предварительно вычисляет набор различных ключей, которые будут хешироваться в одном ведре хеш-таблицы (или даже иметь одно и то же значение хеша). Цель атаки — получить наихудшее поведение алгоритма (O(n) вместо амортизированного O(1), см. Сложность алгоритмов для получения подробностей) при вводе данных в таблицу.

Чтобы избежать этого наихудшего поведения, вычисление значения хеша, выполняемое функцией qHash(), может быть зашифровано случайным значением, что сводит к минимуму воздействие атаки. Это значение автоматически генерируется QHash один раз на процесс и затем передаётся QHash в качестве второго аргумента перегрузки функции qHash() с двумя аргументами.

Эта рандомизация QHash включена по умолчанию. Хотя программы никогда не должны зависеть от определенного порядка QHash, могут быть ситуации, когда вам временно требуется детерминированное поведение, например, для отладки или регрессионного тестирования. Чтобы отключить рандомизацию, определите переменную среды QT_HASH_SEED со значением 0. Кроме того, вы можете вызвать функцию qSetGlobalQHashSeed() со значением 0.

См. также QHashIterator, QMutableHashIterator, QMap и QSet.

Документация по типу членов

QHash::ConstIterator

Синоним в стиле Qt для QHash::const_iterator.

QHash::Iterator

Синоним в стиле Qt для QHash::iterator.

[since 5.10] QHash::const_key_value_iterator

QHash::const_key_value_iterator предоставляет итератор в стиле STL для QHash.

QHash::const_key_value_iterator — это по существу то же самое, что и QHash::const_iterator, за исключением того, что оператор*() возвращает пару ключ/значение вместо значения.

Этот псевдоним типа был введён в Qt 5.10.

См. также QKeyValueIterator.

[alias] QHash::difference_type

Псевдоним для ptrdiff_t. Предоставлен для совместимости со STL.

[alias] QHash::key_type

Псевдоним для Key. Предоставлен для совместимости со STL.

[since 5.10] QHash::key_value_iterator

QHash::key_value_iterator предоставляет итератор в стиле STL для QHash.

QHash::key_value_iterator — это по существу то же самое, что и QHash::iterator, за исключением того, что оператор*() возвращает пару ключ/значение вместо значения.

Этот псевдоним типа был введён в Qt 5.10.

См. также QKeyValueIterator.

[alias] QHash::mapped_type

Псевдоним для T. Предоставлен для совместимости со STL.

[alias] QHash::size_type

Тип для int. Предоставлен для совместимости со STL.

Документация функций-членов

Вставляет новый элемент в контейнер. Новый элемент создаётся на месте с использованием args в качестве аргументов для его создания.

Возвращает итератор, указывающий на новый элемент.

[since 5.14] template <typename InputIterator> QHash::QHash(InputIterator begin, InputIterator end)

Создаёт хеш-таблицу с копией каждого элемента в диапазоне итераторов [begin, end). Элементы, перебираемые в этом диапазоне, должны быть объектами с first и second членами данных (например, QPair, std::pair, и т. д.), преобразуемыми в Key и T соответственно; или итераторы должны иметь key() и value() члены-функции, возвращающие ключ, преобразуемый в Key и значение, преобразуемое в T соответственно.

Эта функция была добавлена в Qt 5.14.

[since 5.2] QHash::QHash(QHash<Key, T> &&other)

Создаёт экземпляр QHash, указывая его на тот же объект, на который указывал other. Перемещение.

Эта функция была добавлена в Qt 5.2.

QHash::QHash(const QHash<Key, T> &other)

Создаёт копию other.

Эта операция выполняется за постоянное время, потому что QHash использует явное совместное использование. Это делает возвращение QHash из функции очень быстрым. Если модифицируется общий экземпляр, он будет скопирован (copy-on-write), что займёт линейное время.

См. также operator=().

[since 5.1] QHash::QHash(std::initializer_list<std::pair<Key, T> > list)

Создаёт хеш-таблицу с копией каждого элемента из списка инициализации list.

Эта функция была добавлена в Qt 5.1.

QHash::QHash()

Создаёт пустой хеш.

См. также clear().

[since 5.2] QHash<Key, T> &QHash::operator=(QHash<Key, T> &&other)

Перемещает присвоение other текущему экземпляру QHash.

Эта функция была добавлена в Qt 5.2.

QHash<Key, T> &QHash::operator=(const QHash<Key, T> &other)

Присваивает other текущему хешу и возвращает ссылку на этот хеш.

QHash::~QHash()

Уничтожает хеш. Ссылки на значения в хеше и все итераторы этого хеша становятся недействительными.

QHash::iterator QHash::begin()

Возвращает итератор STL-стиля, указывающий на первый элемент в хеше.

См. также constBegin() и end().

QHash::const_iterator QHash::begin() const

Это перегруженная функция.

qsizetype QHash::capacity() const

Возвращает количество ведер во внутренней хеш-таблице QHash.

Единственная цель этой функции — предоставить способ тонкой настройки использования памяти QHash. Как правило, вам редко придётся вызывать эту функцию. Если вы хотите узнать, сколько элементов в хеше, вызовите size().

См. также reserve() и squeeze().

[since 5.0] QHash::const_iterator QHash::cbegin() const

Возвращает константный итератор STL-стиля, указывающий на первый элемент в хеше.

Эта функция была добавлена в Qt 5.0.

См. также begin() и cend().

[since 5.0] QHash::const_iterator QHash::cend() const

Возвращает константный итератор STL-стиля, указывающий на воображаемый элемент после последнего элемента в хеше.

Эта функция была добавлена в Qt 5.0.

См. также cbegin() и end().

void QHash::clear()

Удаляет все элементы из хеша и освобождает всю используемую им память.

См. также remove().

QHash::const_iterator QHash::constBegin() const

Возвращает константный итератор STL-стиля, указывающий на первый элемент в хеше.

См. также begin() и constEnd().

QHash::const_iterator QHash::constEnd() const

Возвращает константный итератор STL-стиля, указывающий на воображаемый элемент после последнего элемента в хеше.

См. также constBegin() и end().

QHash::const_iterator QHash::constFind(const Key &key) const

Возвращает итератор, указывающий на элемент с ключом key в хеше.

Если в хеше нет элемента с ключом key, функция возвращает constEnd().

См. также find().

[since 5.10] QHash::const_key_value_iterator QHash::constKeyValueBegin() const

Возвращает константный итератор STL-стиля, указывающий на первую запись в хеше.

Эта функция была добавлена в Qt 5.10.

См. также keyValueBegin().

[since 5.10] QHash::const_key_value_iterator QHash::constKeyValueEnd() const

Возвращает константный итератор STL-стиля, указывающий на воображаемый элемент после последней записи в хеше.

Эта функция была добавлена в Qt 5.10.

См. также constKeyValueBegin().

bool QHash::contains(const Key &key) const

Возвращает true, если хеш содержит элемент с ключом key; в противном случае возвращает false.

См. также count() и QMultiHash::contains().

qsizetype QHash::count(const Key &key) const

Возвращает количество элементов, связанных с ключом key.

См. также contains().

qsizetype QHash::count() const

Это перегруженная функция.

То же самое, что и size().

bool QHash::empty() const

Эта функция предоставлена для совместимости со STL. Она эквивалентна isEmpty(), возвращая true, если хеш пустой; в противном случае возвращает false.

QHash::iterator QHash::end()

Возвращает итератор STL-стиля, указывающий на воображаемый элемент после последнего элемента в хеше.

См. также begin() и constEnd().

QHash::const_iterator QHash::end() const

Это перегруженная функция.

[since 5.7] QHash::iterator QHash::erase(QHash::const_iterator pos)

Удаляет пару (ключ, значение), связанную с итератором pos из хеша и возвращает итератор на следующий элемент в хеше.

Эта функция никогда не вызывает повторное хеширование внутренней структуры данных QHash. Это означает, что её можно безопасно вызывать во время итерации и она не повлияет на порядок элементов в хеше. Например:

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;
    }
}

Эта функция была добавлена в Qt 5.7.

См. также remove(), take() и find().

QHash::iterator QHash::find(const Key &key)

Возвращает итератор, указывающий на элемент с заданным ключом в хэше.

Если в хэше нет элемента с заданным ключом, функция возвращает end().

Если в хэше есть несколько элементов с одинаковым ключом, функция возвращает итератор, указывающий на значение, добавленное последним. Другие значения можно получить, инкрементируя итератор. Например, вот фрагмент кода, который перебирает все элементы с одинаковым ключом:

QHash<QString, int> hash;
...
QHash<QString, int>::const_iterator i = hash.find("HDR");
while (i != hash.end() && i.key() == "HDR") {
    cout << i.value() << Qt::endl;
    ++i;
}

См. также value() и values().

QHash::const_iterator QHash::find(const Key &key) const

Это перегруженная функция.

QHash::iterator QHash::insert(const Key &key, const T &value)

Вставляет новый элемент с заданным ключом и значением value.

Если элемент с заданным ключом уже существует, значение этого элемента заменяется на value.

[since 5.15] void QHash::insert(const QHash<Key, T> &other)

Вставляет все элементы из хэша other в текущий хэш.

Если ключ присутствует в обоих хэшах, его значение заменяется значением из other.

Примечание: Если other содержит несколько записей с одинаковым ключом, конечное значение ключа является неопределённым.

Функция была добавлена в Qt 5.15.

bool QHash::isEmpty() const

Возвращает true если хэш не содержит элементов; в противном случае возвращает false.

См. также size().

Key QHash::key(const T &value, const Key &defaultKey = Key()) const

Возвращает первый ключ, сопоставленный со значением value, или defaultKey, если в хэше нет элемента, сопоставленного со значением value.

Эта функция может быть медленной (линейное время), потому что внутренняя структура данных QHash оптимизирована для быстрого поиска по ключу, а не по значению.

[since 5.6] QHash::key_iterator QHash::keyBegin() const

Возвращает постоянный итератор в стиле STL, указывающий на первый ключ в хэше.

Функция была добавлена в Qt 5.6.

См. также keyEnd().

[since 5.6] QHash::key_iterator QHash::keyEnd() const

Возвращает постоянный итератор в стиле STL, указывающий на воображаемый элемент после последнего ключа в хэше.

Функция была добавлена в Qt 5.6.

См. также keyBegin().

[since 5.10] QHash::key_value_iterator QHash::keyValueBegin()

Возвращает итератор в стиле STL, указывающий на первую запись в хэше.

Функция была добавлена в Qt 5.10.

См. также keyValueEnd().

[since 5.10] QHash::const_key_value_iterator QHash::keyValueBegin() const

Возвращает постоянный итератор в стиле STL, указывающий на первую запись в хэше.

Функция была добавлена в Qt 5.10.

См. также keyValueEnd().

[since 5.10] QHash::key_value_iterator QHash::keyValueEnd()

Возвращает итератор в стиле STL, указывающий на воображаемый элемент после последней записи в хэше.

Функция была добавлена в Qt 5.10.

См. также keyValueBegin().

[since 5.10] QHash::const_key_value_iterator QHash::keyValueEnd() const

Возвращает постоянный итератор в стиле STL, указывающий на воображаемый элемент после последней записи в хэше.

Функция была добавлена в Qt 5.10.

См. также keyValueBegin().

QList<Key> QHash::keys() const

Возвращает список, содержащий все ключи в хэше в произвольном порядке.

Порядок гарантированно совпадает с порядком, используемым функцией values().

Функция создает новый список за линейное время. Это время и используемая память могут быть предотвращены итерацией от keyBegin() до keyEnd().

См. также values() и key().

QList<Key> QHash::keys(const T &value) const

Это перегруженная функция.

Возвращает список, содержащий все ключи, связанные со значением value, в произвольном порядке.

Эта функция может быть медленной (линейное время), так как внутренняя структура данных QHash оптимизирована для быстрого поиска по ключу, а не по значению.

float QHash::load_factor() const

Возвращает текущий коэффициент заполнения внутренней хэш-таблицы QHash. Это то же самое, что capacity()/size(). Реализация стремится поддерживать коэффициент заполнения между 0,25 и 0,5. Это предотвращает слишком много коллизий в хэш-таблице, которые снизят производительность.

Даже при низком коэффициенте заполнения, реализация хэш-таблицы имеет очень низкую накладную стоимость памяти.

Этот метод предназначен только для диагностических целей, и вам вряд ли придётся его вызывать.

См. также reserve() и squeeze().

bool QHash::remove(const Key &key)

Удаляет элемент с заданным ключом из хэша. Возвращает true, если ключ существует в хэше и элемент был удалён, и false в противном случае.

См. также clear() и take().

[since 6.1] template <typename Predicate> qsizetype QHash::removeIf(Predicate pred)

Удаляет все элементы, для которых предикат pred возвращает true из хэша.

Функция поддерживает предикаты, принимающие аргумент типа QHash<Key, T>::iterator, или аргумент типа std::pair<const Key &, T &>.

Возвращает количество удалённых элементов, если таковые имеются.

Функция была добавлена в Qt 6.1.

См. также clear() и take().

void QHash::reserve(qsizetype size)

Обеспечивает, чтобы внутренняя хэш-таблица QHash имела место для хранения как минимум size элементов без необходимости расширения хэш-таблицы.

Это подразумевает, что хэш-таблица будет содержать как минимум 2 * size корзин, чтобы обеспечить хорошую производительность.

Эта функция полезна для кода, которому необходимо построить огромный хэш и который хочет избежать многократного перераспределения. Например:

QHash<QString, int> hash;
hash.reserve(20000);
for (int i = 0; i < 20000; ++i)
    hash.insert(keys[i], values[i]);

В идеале size должен соответствовать максимальному ожидаемому количеству элементов в хэше. QHash затем выберет наименьшее возможное количество корзин, которое позволит хранить size элементов в таблице без расширения внутренней хэш-таблицы. Если size является заниженной оценкой, худшим сценарием будет то, что QHash будет немного медленнее.

В целом, вам редко придётся вызывать эту функцию. Внутренняя хэш-таблица QHash автоматически увеличивается, чтобы обеспечить хорошую производительность, не тратя слишком много памяти.

См. также squeeze() и capacity().

qsizetype QHash::size() const

Возвращает количество элементов в хэше.

См. также isEmpty() и count().

void QHash::squeeze()

Уменьшает размер внутренней хэш-таблицы QHash, чтобы сэкономить память.

Единственная цель этой функции — предоставить способ точной настройки использования памяти QHash. В целом, вам редко придётся вызывать эту функцию.

См. также reserve() и capacity().

void QHash::swap(QHash<Key, T> &other)

Меняет местами хэш other с текущим хэшем. Эта операция очень быстрая и никогда не завершается неудачно.

T QHash::take(const Key &key)

Удаляет элемент с заданным ключом из хэша и возвращает связанное с ним значение.

Если элемент не существует в хэше, функция просто возвращает значение по умолчанию.

Если вам не нужно значение возврата, remove() более эффективна.

См. также remove().

T QHash::value(const Key &key, const T &defaultValue = T()) const

Это перегруженная функция.

Возвращает значение, связанное с ключом.

Если в хэш-таблице нет элемента с ключом, функция возвращает defaultValue, которое является значением по умолчанию, если параметр не указан.

QList<T> QHash::values() const

Возвращает список, содержащий все значения в хэш-таблице в произвольном порядке.

Порядок гарантированно совпадает с порядком, используемым функцией keys().

Эта функция создаёт новый список за линейное время. Время и объём памяти, которые это влечёт, можно избежать, итерируясь от keyValueBegin() до keyValueEnd().

См. также keys() и value().

template <typename U> QTypeTraits::compare_eq_result<U> QHash::operator!=(const QHash<Key, T> &other) const

Возвращает true если other не равно этому хэшу; в противном случае возвращает false.

Два хэша считаются равными, если они содержат одинаковые пары (ключ, значение).

Эта функция требует, чтобы тип значения реализовывал operator==().

См. также operator==().

template <typename U> QTypeTraits::compare_eq_result<U> QHash::operator==(const QHash<Key, T> &other) const

Возвращает true если other равно этому хэшу; в противном случае возвращает false.

Два хэша считаются равными, если они содержат одинаковые пары (ключ, значение).

Эта функция требует, чтобы тип значения реализовывал operator==().

См. также operator!=().

T &QHash::operator[](const Key &key)

Возвращает значение, связанное с ключом, в качестве изменяемой ссылки.

Если в хэше нет элемента с ключом, функция вставляет значение по умолчанию в хэш с ключом и возвращает ссылку на него.

См. также insert() и value().

const T QHash::operator[](const Key &key) const

Это перегруженная функция.

То же самое, что и value().

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);
}

#ifndef EMPLOYEE_H
#define EMPLOYEE_H

class Employee
{
public:
    Employee() {}
    Employee(const QString &name, QDate dateOfBirth);
    ...

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_H

{0, 1, 2}

{1, 2, 0}

inline size_t qHash(const std::vector<int> &key, size_t seed = 0)
{
    return qHashRange(key.begin(), key.end(), seed);
}

{0, 1, 2}

{1, 2, 0}

inline size_t qHash(const std::unordered_set<int> &key, size_t seed = 0)
{
    return qHashRangeCommutative(key.begin(), key.end(), seed);
}