Класс 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 использует последнюю (обратите внимание, что вы можете просто определить перегрузку с двумя аргументами и использовать значение по умолчанию для параметра посева).

Вот частичный список типов 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 предоставляет итератор 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(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

Возвращает итератор, указывающий на элемент с 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.

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

Эта функция может быть медленной (линейное время), так как внутренняя структура данных 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==().

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