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

Если вы хотите использовать другие типы в качестве ключей, убедитесь, что вы предоставили оператор==() и реализацию 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(), может быть засаливано случайным семением, которое устраняет масштаб атаки. Это семя автоматически генерируется 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 предоставляет итератор const в стиле STL для QHash и QMultiHash.

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

Этот тип был введен в 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*() возвращает пару ключ/значение вместо значения.

Этот тип был введен в 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 из функции очень быстрым. Если изменён общий экземпляр, он будет скопирован (копирование при записи), и это займёт линейное время.

См. также 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

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

Если в хэше нет элемента с заданным key, функция возвращает 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 , если хэш содержит элемент с указанным key; в противном случае возвращает false.

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

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

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

См. также 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), хранящихся под key. Если диапазон пуст, оба итератора будут равны 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)

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

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

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

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)

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

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

Если есть несколько элементов с одинаковым key, значение самого последнего вставленного элемента заменяется на value.

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

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

Вставляет новый элемент с заданным key и значением 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() с key.

См. также 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, возвращается значение последнего вставленного.

См. также 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);
}