Класс 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() вместо оператора[]() для поиска ключа в хеш-таблице. Причина в том, что оператор[]() молча вставляет элемент в хеш-таблицу, если нет элемента с таким же ключом (если хеш-таблица не const). Например, следующий фрагмент кода создаст 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 использует последнюю (обратите внимание, что вы можете просто определить версию с двумя аргументами и использовать значение по умолчанию для параметра seed).

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

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

Аргумент seed имеет то же значение, что и для 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(), может быть «засолено» случайным seed, что сводит к минимуму степень атаки. Этот seed автоматически генерируется QHash один раз на процесс и затем передаётся QHash в качестве второго аргумента перегрузки функции qHash() с двумя аргументами.

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

См. также 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 предоставляет итератор const в стиле 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.

Функция была введена в 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

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

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

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

QList<T> QHash::values() const

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

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

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

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

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

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

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

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

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

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