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

Если вам нужно только извлечь значения из хэша (а не ключи), вы также можете использовать 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 для предотвращения атак на алгоритмическую сложность. algorithmic complexity attacks. Если определены перегрузки как с одним, так и с двумя аргументами для типа ключа, 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, 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.

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

template <typename InputIterator> QHash::QHash(InputIterator begin, InputIterator end)

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

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

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() << 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)

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

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

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

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

Вставляет все элементы из хеша other в этот хеш.

Если ключ присутствует в обоих хешах, его значение заменяется значением, хранящимся в other.

Примечание: Если other содержит несколько записей с одинаковым ключом, конечное значение ключа не определено.

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

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

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

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

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

QHash::key_iterator QHash::keyEnd() const

Возвращает 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

Возвращает 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

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

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

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

QList<Key> QHash::keys() const

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

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

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

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

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

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

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

int QHash::remove(const Key &key)

Удаляет все элементы, имеющие ключ key из хэша. Возвращает количество удалённых элементов, которое равно 1, если ключ существует в хэше, и 0 в противном случае.

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

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().

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