Класс 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, можно использовать итератор. 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

Однако вы можете хранить несколько значений на один ключ, используя 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) << Qt::endl;

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

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

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

QHash<QString, int> hash;
...
foreach (int value, hash)
    cout << value << Qt::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 для предотвращения атак на алгоритмическую сложность. Если определены перегрузки с одним и двумя аргументами для типа ключа, используется последняя (обратите внимание, что вы можете просто определить версию с двумя аргументами и использовать значение по умолчанию для параметра инициализации).

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

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

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

См. также QKeyValueIterator.

typedef QHash::mapped_type

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

typedef QHash::size_type

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

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

QHash::QHash(InputIterator begin, InputIterator end)

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

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

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

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

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

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

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

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

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

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

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

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

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

QHash::QHash()

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

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

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

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

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

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

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

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() << Qt::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, возвращается значение последнего вставленного элемента.

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

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

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

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

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

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

T &QHash::operator[](const 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);
}