QHash Class

相关的非成员函数

[since 6.1] template < typename Key, typename T, typename Predicate > qsizetype erase_if(QHash<Key, T> &hash, Predicate pred)

从哈希表hash 中移除所有满足谓词pred 的元素。

该函数支持接受类型为QHash<Key, T>::iterator 或std::pair<const Key &, T &> 的谓词。

返回被移除的元素数量（如有）。

该函数在 Qt 6.1 中引入。

[constexpr noexcept, since 6.5] template <typename Enum, std::enable_if_t<std::is_enum_v<Enum>, bool> = true> size_t qHash(Enum key, size_t seed = 0)

返回key 的哈希值，并使用seed 作为计算的种子。

该函数在 Qt 6.5 中引入。

[noexcept, since 6.0] size_t qHash(QByteArrayView key, size_t seed = 0)

返回key 的哈希值，并使用seed 作为计算的种子。

该函数在 Qt 6.0 中引入。

[constexpr noexcept] size_t qHash(uchar key, size_t seed = 0)

返回key 的哈希值，并使用seed 作为计算的种子。

[constexpr noexcept] size_t qHash(uint key, size_t seed = 0)

返回key 的哈希值，并使用seed 作为计算的种子。

[constexpr noexcept] size_t qHash(ulong key, size_t seed = 0)

返回key 的哈希值，并使用seed 作为计算的种子。

[constexpr noexcept] size_t qHash(ushort key, size_t seed = 0)

返回key 的哈希值，并使用seed 作为计算的种子。

[constexpr noexcept, since 6.0] size_t qHash(wchar_t key, size_t seed = 0)

返回key 的哈希值，并使用seed 作为计算的种子。

该函数于 Qt 6.0 中引入。

[noexcept] size_t qHash(QDate key, size_t seed = 0)

返回key 的哈希值，并使用seed 作为计算的种子。

[noexcept] size_t qHash(QLatin1StringView key, size_t seed = 0)

返回key 的哈希值，并使用seed 作为计算的种子。

[noexcept, since 6.0] size_t qHash(QPoint key, size_t seed = 0)

返回key 的哈希值，并使用seed 作为计算的种子。

该函数在 Qt 6.0 中引入。

[noexcept] size_t qHash(QTime key, size_t seed = 0)

返回key 的哈希值，并使用seed 作为计算的种子。

[constexpr noexcept, since 6.9] template <typename T, std::enable_if_t<std::is_same_v<T, bool>, bool>> size_t qHash(T key, size_t seed)

返回key 的哈希值，并使用seed 作为计算的种子。

该函数于 Qt 6.9 中引入。

[constexpr noexcept] size_t qHash(char key, size_t seed = 0)

返回key 的哈希值，并使用seed 作为计算的种子。

[constexpr noexcept, since 6.0] size_t qHash(char16_t key, size_t seed = 0)

返回key 的哈希值，并使用seed 作为计算的种子。

该函数在 Qt 6.0 中引入。

[constexpr noexcept, since 6.0] size_t qHash(char32_t key, size_t seed = 0)

返回key 的哈希值，并使用seed 作为计算的种子。

该函数在 Qt 6.0 中引入。

[constexpr noexcept, since 6.0] size_t qHash(char8_t key, size_t seed = 0)

返回key 的哈希值，并使用seed 作为计算的种子。

该函数于 Qt 6.0 中引入。

[noexcept] size_t qHash(const QBitArray &key, size_t seed = 0)

返回key 的哈希值，并使用seed 作为计算的初始值。

[noexcept] size_t qHash(const QByteArray &key, size_t seed = 0)

返回key 的哈希值，并使用seed 作为计算的种子。

[constexpr noexcept] size_t qHash(const QChar key, size_t seed = 0)

返回key 的哈希值，并使用seed 作为计算的种子。

size_t qHash(const QDateTime &key, size_t seed = 0)

返回key 的哈希值，并使用seed 作为计算的种子。

[noexcept(...)] template <typename Key, typename T> size_t qHash(const QHash<Key, T> &key, size_t seed = 0)

返回key 的哈希值，并使用seed 作为计算的初始值。

Key 和T 这两种类型必须被 qHash() 支持。

[noexcept(...)] template <typename T> size_t qHash(const QSet<T> &key, size_t seed = 0)

返回key 的哈希值，并使用seed 作为计算的种子。

T 类型必须被 qHash() 支持。

该哈希值与key 中元素的顺序无关，也就是说，包含相同元素的集合将生成相同的哈希值。

[noexcept] size_t qHash(const QString &key, size_t seed = 0)

返回key 的哈希值，并使用seed 作为计算的初始值。

[since 6.0] size_t qHash(const QTypeRevision &key, size_t seed = 0)

返回key 的哈希值，并使用seed 作为计算的种子。

该函数于 Qt 6.0 中引入。

[noexcept] size_t qHash(const QUrl &key, size_t seed = 0)

返回key 的哈希值，并使用seed 作为计算的种子。

size_t qHash(const QVersionNumber &key, size_t seed = 0)

返回key 的哈希值，并使用seed 作为计算的种子。

[noexcept] template <typename T> size_t qHash(const T *key, size_t seed = 0)

返回key 的哈希值，并使用seed 作为计算的种子。

[constexpr noexcept(...), since 6.12] template <typename T> size_t qHash(const std::optional<T> &key, size_t seed = 0)

返回key 的哈希值，并使用seed 作为计算的种子。

qHash() 必须支持T 类型。

这等同于

key ? qHash(*key, seed) : qHash(std::nullopt, seed);

特别是，如果启用了key （has_value() ），则保证key 的哈希值与key.value() 的哈希值相同，且所有已禁用（!has_value() ）的可选项，无论其类型如何，都会哈希为相同的值。

该函数在 Qt 6.12 中引入。

另请参阅 qHash (std::nullopt_t, size_t)。

[noexcept(...)] template <typename T1, typename T2> size_t qHash(const std::pair<T1, T2> &key, size_t seed = 0)

返回key 的哈希值，并使用seed 作为计算的种子。

T1 和T2 这两种类型必须被 qHash() 支持。

[noexcept] size_t qHash(double key, size_t seed = 0)

返回key 的哈希值，并使用seed 作为计算的种子。

[noexcept] size_t qHash(float key, size_t seed = 0)

返回key 的哈希值，并使用seed 作为计算的种子。

[constexpr noexcept] size_t qHash(int key, size_t seed = 0)

返回key 的哈希值，并使用seed 作为计算的初始值。

[constexpr noexcept] size_t qHash(long key, size_t seed = 0)

返回key 的哈希值，并使用seed 作为计算的种子。

[noexcept] size_t qHash(long double key, size_t seed = 0)

返回key 的哈希值，并使用seed 作为计算的初始值。

[constexpr noexcept, since 6.8] size_t qHash(qint128 key, size_t seed = 0)

返回key 的哈希值，并使用seed 作为计算的种子。

该函数于 Qt 6.8 版本中引入。

[constexpr noexcept] size_t qHash(qint64 key, size_t seed = 0)

返回key 的哈希值，并使用seed 作为计算的种子。

[constexpr noexcept, since 6.8] size_t qHash(quint128 key, size_t seed = 0)

返回key 的哈希值，并使用seed 作为计算的种子。

该函数在 Qt 6.8 中引入。

[constexpr noexcept] size_t qHash(quint64 key, size_t seed = 0)

返回key 的哈希值，并使用seed 作为计算的种子。

[constexpr noexcept] size_t qHash(short key, size_t seed = 0)

返回key 的哈希值，并使用seed 作为计算的种子。

[constexpr noexcept] size_t qHash(signed char key, size_t seed = 0)

返回key 的哈希值，并使用seed 作为计算的种子。

[constexpr noexcept, since 6.0] size_t qHash(std::nullptr_t key, size_t seed = 0)

返回key 的哈希值，并使用seed 作为计算的种子。

该函数自 Qt 6.0 起引入。

[noexcept] size_t qHashBits(const void *p, size_t len, size_t seed = 0)

返回由 `p` 指向的、大小为 `len ` 的内存块的哈希值，并使用 `seed ` 作为计算的种子。

仅在为自定义类型实现qHash() 时使用此函数。例如，以下是针对 std::vector<int> 实现qHash() 重载的方法：

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

这利用了 std::vector 将其数据连续布局这一特性。如果情况并非如此，或者所包含的类型有填充，则应改用qHashRange()。

需要再次强调的是，qHashBits() 的实现——就像 Qt 提供的qHash() 重载一样——可能会随时发生变化。您绝不能依赖 qHashBits() 在不同 Qt 版本中（对于相同的输入）会返回相同结果这一事实。

另请参阅 qHashRange() 和qHashRangeCommutative()。

[constexpr noexcept(...), since 6.0] template <typename... T> size_t qHashMulti(size_t seed, const T &... args)

返回args 的哈希值，使用seed 作为计算种子，通过依次对每个元素应用qHash()，并将各哈希值合并为一个最终值。

请注意，参数的顺序至关重要。如果顺序无关紧要，请改用qHashMultiCommutative()。如果要对原始内存进行哈希处理，请使用qHashBits()；如果要对一个范围进行哈希处理，请使用qHashRange()。

提供此函数是为了方便您为自定义类型实现 `qHash()`。例如，以下是您如何为类 `Employee` 实现 `qHash()` 重载的方法：

#ifndef EMPLOYEE_H
#define EMPLOYEE_H

class Employee
{
public:
    Employee() {}
    Employee(const QString &name, QDate dateOfBirth);
    QString name() const { return myName; }
    QDate dateOfBirth() const { return myDateOfBirth; }
    //...

private:
    QString myName;
    QDate myDateOfBirth;
};

inline bool operator==(const Employee &e1, const Employee &e2)
{
    return e1.name() == e2.name()
           && e1.dateOfBirth() == e2.dateOfBirth();
}

inline size_t qHash(const Employee &key, size_t seed)
{
    return qHashMulti(seed, key.name(), key.dateOfBirth());
}

#endif // EMPLOYEE_H

该函数在 Qt 6.0 中引入。

另请参阅 qHashMultiCommutative 和qHashRange 。

[constexpr noexcept(...), since 6.0] template <typename... T> size_t qHashMultiCommutative(size_t seed, const T &... args)

返回args 的哈希值，使用seed 作为计算种子，通过依次对每个元素应用qHash()，并将各哈希值合并为一个最终值。

参数的顺序无关紧要。如果顺序确实重要，请改用 `qHashMulti()`，因为它可能产生更高质量的哈希结果。如果要对原始内存进行哈希，请使用 `qHashBits()`；如果要对一个范围进行哈希，请使用 `qHashRange()`。

提供此函数是为了方便您为自定义类型实现 `qHash()` 函数。

该函数于 Qt 6.0 中引入。

另请参阅 qHashMulti 和qHashRange 。

[noexcept(...)] template <typename InputIterator> size_t qHashRange(InputIterator first, InputIterator last, size_t seed = 0)

返回范围 [first,last) 的哈希值，使用seed 作为计算种子，通过依次对每个元素应用qHash()，并将各哈希值合并为一个值。

该函数的返回值取决于该范围中元素的顺序。这意味着

{0, 1, 2}

和

{1, 2, 0}

哈希为不同的值。如果顺序无关紧要（例如在哈希表中），请改用qHashRangeCommutative()。若对原始内存进行哈希处理，请使用qHashBits()。

仅将此函数用于为自定义类型实现 `qHash()`。例如，以下是针对 `std::vector<int>` 实现 `qHash()` 重载的方法：

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

需要再次强调的是，qHashRange() 的实现——就像 Qt 提供的qHash() 重载一样——可能会随时发生变化。即使元素类型的qHash() 在不同 Qt 版本中结果一致，你也绝不能依赖 qHashRange() 在不同 Qt 版本中（对于相同的输入）会返回相同结果这一事实。

另请参阅 qHashBits() 和qHashRangeCommutative()。

[noexcept(...)] template <typename InputIterator> size_t qHashRangeCommutative(InputIterator first, InputIterator last, size_t seed = 0)

返回范围 [first,last) 的哈希值，使用seed 作为计算种子，通过依次对每个元素应用qHash()，并将各哈希值合并为一个值。

该函数的返回值不依赖于该范围中元素的顺序。这意味着

{0, 1, 2}

和

{1, 2, 0}

哈希结果相同。如果顺序很重要（例如对于向量和数组），请改用qHashRange()。若对原始内存进行哈希，请使用qHashBits()。

仅将此函数用于为自定义类型实现 `qHash()`。例如，以下是您可以为 `std::unordered_set<int>` 实现 `qHash()` 重载的方法：

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

需要再次强调的是，qHashRangeCommutative() 的实现——与 Qt XML 提供的qHash() 重载一样——可能会随时发生变化。 即使针对该元素类型的 `qHash()` 在不同 Qt 版本中返回相同结果，你也绝不能依赖 `qHashRangeCommutative()` 在不同 Qt 版本中（对于相同的输入）会返回相同结果这一事实。

另请参阅 qHashBits() 和qHashRange()。

[noexcept] bool operator!=(const QHash<Key, T> &lhs, const QHash<Key, T> &rhs)

如果lhs 哈希值与rhs 哈希值不相同，则返回true ；否则返回false 。

如果两个哈希表包含相同的 (键, 值) 对，则认为它们相等。

此函数要求值类型实现operator==() 。

另请参阅 operator==()。

template <typename Key, typename T> QDataStream &operator<<(QDataStream &out, const QHash<Key, T> &hash)

将哈希hash 写入流out 。

此函数要求键和值的类型都实现operator<<() 接口。

另请参阅 《Qt 数据类型的序列化》。

[noexcept] bool operator==(const QHash<Key, T> &lhs, const QHash<Key, T> &rhs)

如果lhs 哈希与rhs 哈希相等，则返回true ；否则返回false 。

如果两个哈希表包含相同的 (键, 值) 对，则认为它们相等。

此函数要求值类型实现operator==() 。

另请参阅 operator!=()。

template <typename Key, typename T> QDataStream &operator>>(QDataStream &in, QHash<Key, T> &hash)

从流in 中读取哈希，并将其写入hash 。

此函数要求键和值的类型都实现operator>>() 接口。

另请参阅 《Qt 数据类型的序列化》。