Класс QHash

Класс 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 << endl;
}

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

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

Если вы хотите перебрать все пары (ключ, значение), хранящиеся в 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() << endl;
}

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

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

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

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

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

Однако вы можете хранить несколько значений на один ключ, используя insertMulti() вместо insert() (или используя удобный подкласс QMultiHash). Если вы хотите получить все значения для одного ключа, вы можете использовать values(const Key &key), которая возвращает QList<T>:

QList<int> values = hash.values("plenty");
for (int i = 0; i < values.size(); ++i)
    cout << values.at(i) << endl;

Элементы с одинаковым ключом доступны от недавно вставленного к менее недавно вставленному. Более эффективный подход заключается в вызове find() для получения итератора для первого элемента с ключом и итерации оттуда:

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

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

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

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

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

Функция хэширования qHash()

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

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

Для типа ключа K, функция qHash должна иметь одну из этих сигнатур:

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

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

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

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

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

Пример:

#ifndef EMPLOYEE_H
#define EMPLOYEE_H

class Employee
{
public:
    Employee() {}
    Employee(const QString &name, const 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 uint qHash(const Employee &key, uint seed)
{
    return qHash(key.name(), seed) ^ key.dateOfBirth().day();
}

#endif // EMPLOYEE_H

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

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

Атаки на алгоритмическую сложность

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

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

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

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

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

typedef QHash::ConstIterator

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

typedef QHash::Iterator

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

typedef QHash::const_key_value_iterator

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

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

Этот typedef был представлен в Qt 5.10.

См. также QKeyValueIterator.

typedef QHash::difference_type

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

typedef QHash::key_type

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

typedef QHash::key_value_iterator

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

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

Этот typedef был представлен в Qt 5.10.

См. также QKeyValueIterator.

typedef QHash::mapped_type

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

typedef QHash::size_type

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

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

QHash::QHash()

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

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

QHash::QHash(std::initializer_list<std::pair<Key, T> > list)

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

Эта функция доступна только если программа компилируется в режиме C++11.

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

QHash::QHash(const QHash<K, V> &other)

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

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

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

QHash::QHash(QHash<K, V> &&other)

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

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

QHash::~QHash()

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

QHash::iterator QHash::begin()

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

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

QHash::const_iterator QHash::begin() const

Это перегруженный метод.

int QHash::capacity() const

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

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

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

QHash::const_iterator QHash::cbegin() const

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

Этот метод был добавлен в Qt 5.0.

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

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

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

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

Этот метод был добавлен в Qt 4.1.

См. также find() и QMultiHash::constFind().

QHash::const_key_value_iterator QHash::constKeyValueBegin() const

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

Этот метод был добавлен в Qt 5.10.

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

QHash::const_key_value_iterator QHash::constKeyValueEnd() const

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

Этот метод был добавлен в Qt 5.10.

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

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

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

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

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

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

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

int 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

Это перегруженный метод.

QPair<QHash::iterator, QHash::iterator> QHash::equal_range(const Key &key)

Возвращает пару итераторов, определяющих диапазон значений [first, second), которые хранятся под ключом. Если диапазон пуст, оба итератора будут равны end().

Этот метод был добавлен в Qt 5.7.

QPair<QHash::const_iterator, QHash::const_iterator> QHash::equal_range(const Key &key) const

Это перегруженный метод.

Этот метод был добавлен в Qt 5.7.

QHash::iterator QHash::erase(QHash::const_iterator pos)

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

В отличие от remove() и take(), этот метод никогда не вызывает перехеширование внутренней структуры данных 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::erase(QHash::iterator pos)

Это перегруженный метод.

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() << endl;
    ++i;
}

См. также value(), values(), и QMultiHash::find().

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

Это перегруженный метод.

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

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

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

Если в хеше есть несколько элементов с одинаковым ключом, значение наиболее недавно вставленного элемента заменяется на value.

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

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

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

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

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

bool QHash::isEmpty() const

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

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

const Key QHash::key(const T &value) const

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

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

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

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

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

Это перегруженный метод.

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

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

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

QHash::key_iterator QHash::keyBegin() const

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

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

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

QHash::key_iterator QHash::keyEnd() const

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

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

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

QHash::key_value_iterator QHash::keyValueBegin()

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

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

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

QHash::const_key_value_iterator QHash::keyValueBegin() const

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

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

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

QHash::key_value_iterator QHash::keyValueEnd()

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

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

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

QHash::const_key_value_iterator QHash::keyValueEnd() const

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

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

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

QList<Key> QHash::keys() const

Возвращает список, содержащий все ключи в хэше в произвольном порядке. Ключи, встречающиеся несколько раз в хэше (потому что элементы были вставлены с помощью insertMulti() или использовалась функция unite()), также встречаются несколько раз в списке.

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

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

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

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

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

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

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

int QHash::remove(const Key &key)

Удаляет все элементы, имеющие ключ key из хэша. Возвращает количество удаленных элементов, которое обычно равно 1, но будет равно 0, если ключ не содержится в хэше, или больше 1, если использовалась функция insertMulti() с данным ключом.

См. также clear(), take() и QMultiHash::remove().

void QHash::reserve(int size)

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

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

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

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

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

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

int QHash::size() const

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

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

void QHash::squeeze()

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

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

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

void QHash::swap(QHash<K, V> &other)

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

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

T QHash::take(const Key &key)

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

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

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

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

QList<Key> QHash::uniqueKeys() const

Возвращает список, содержащий все ключи в карте. Ключи, встречающиеся несколько раз в карте (потому что элементы были вставлены с помощью insertMulti() или использовалась функция unite()), встречаются только один раз в возвращаемом списке.

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

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

QHash<K, V> &QHash::unite(const QHash<K, V> &other)

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

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

const T QHash::value(const Key &key) const

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

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

См. также key(), values(), contains() и operator[]().

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

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

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

QList<T> QHash::values() const

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

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

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

QList<T> QHash::values(const Key &key) const

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

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

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

bool QHash::operator!=(const QHash<K, V> &other) const

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

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

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

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

QHash<K, V> &QHash::operator=(const QHash<K, V> &other)

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

QHash<K, V> &QHash::operator=(QHash<K, V> &&other)

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

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

bool QHash::operator==(const QHash<K, V> &other) const

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

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

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

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

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

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

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

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

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

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

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

qHash(qMakePair(key.first, key.second), seed);

inline uint qHash(const std::vector<int> &key, uint seed = 0)
{
    if (key.empty())
        return seed;
    else
        return qHashBits(&key.front(), key.size() * sizeof(int), seed);
}

{0, 1, 2}

{1, 2, 0}

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

{0, 1, 2}

{1, 2, 0}

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