QHash Class

template <typename Key, typename T> class QHash

QHashクラスは、ハッシュ・テーブル・ベースの辞書を提供するテンプレート・クラスです。詳細...

ヘッダー	`#include <QHash>`
CMake：	`find_package(Qt6 REQUIRED COMPONENTS Core)` `target_link_libraries(mytarget PRIVATE Qt6::Core)`
qmake：	`QT += core`

注意:このクラスの関数はすべてリエントラントです。

パブリック型

class	const_iterator
class	iterator
class	key_iterator
	ConstIterator
	Iterator
	const_key_value_iterator
	difference_type
	key_type
	key_value_iterator
	mapped_type
	size_type

パブリック関数

	QHash()
	QHash(std::initializer_list<std::pair<Key, T>> list)
	QHash(InputIterator begin, InputIterator end)
	QHash(const QHash<Key, T> &other)
	QHash(QHash<Key, T> &&other)
	~QHash()
`(since 6.4)` auto	asKeyValueRange() &&
`(since 6.4)` auto	asKeyValueRange() &
`(since 6.4)` auto	asKeyValueRange() const &&
`(since 6.4)` auto	asKeyValueRange() const &
QHash<Key, T>::iterator	begin()
QHash<Key, T>::const_iterator	begin() const
qsizetype	capacity() const
QHash<Key, T>::const_iterator	cbegin() const
QHash<Key, T>::const_iterator	cend() const
void	clear()
QHash<Key, T>::const_iterator	constBegin() const
QHash<Key, T>::const_iterator	constEnd() const
QHash<Key, T>::const_iterator	constFind(const Key &key) const
QHash<Key, T>::const_key_value_iterator	constKeyValueBegin() const
QHash<Key, T>::const_key_value_iterator	constKeyValueEnd() const
bool	contains(const Key &key) const
qsizetype	count(const Key &key) const
qsizetype	count() const
QHash<Key, T>::iterator	emplace(Key &&key, Args &&... args)
QHash<Key, T>::iterator	emplace(const Key &key, Args &&... args)
bool	empty() const
QHash<Key, T>::iterator	end()
QHash<Key, T>::const_iterator	end() const
QHash<Key, T>::iterator	erase(QHash<Key, T>::const_iterator pos)
QHash<Key, T>::iterator	find(const Key &key)
QHash<Key, T>::const_iterator	find(const Key &key) const
void	insert(const QHash<Key, T> &other)
QHash<Key, T>::iterator	insert(const Key &key, const T &value)
bool	isEmpty() const
Key	key(const T &value) const
Key	key(const T &value, const Key &defaultKey) const
QHash<Key, T>::key_iterator	keyBegin() const
QHash<Key, T>::key_iterator	keyEnd() const
QHash<Key, T>::key_value_iterator	keyValueBegin()
QHash<Key, T>::const_key_value_iterator	keyValueBegin() const
QHash<Key, T>::key_value_iterator	keyValueEnd()
QHash<Key, T>::const_key_value_iterator	keyValueEnd() const
QList<Key>	keys() const
QList<Key>	keys(const T &value) const
float	load_factor() const
bool	remove(const Key &key)
`(since 6.1)` qsizetype	removeIf(Predicate pred)
void	reserve(qsizetype size)
qsizetype	size() const
void	squeeze()
void	swap(QHash<Key, T> &other)
T	take(const Key &key)
T	value(const Key &key) const
T	value(const Key &key, const T &defaultValue) const
QList<T>	values() const
bool	operator!=(const QHash<Key, T> &other) const
QHash<Key, T> &	operator=(QHash<Key, T> &&other)
QHash<Key, T> &	operator=(const QHash<Key, T> &other)
bool	operator==(const QHash<Key, T> &other) const
T &	operator[](const Key &key)
const T	operator[](const Key &key) const

`(since 6.1)` qsizetype	erase_if(QHash<Key, T> &hash, Predicate pred)
`(since 6.5)` size_t	qHash(Enum key, size_t seed = 0)
size_t	qHash(const QMqttTopicFilter &filter, size_t seed)
size_t	qHash(QSslEllipticCurve key, size_t seed)
size_t	qHash(QDate key, size_t seed = 0)
size_t	qHash(const QStringRef &key, size_t seed)
size_t	qHash(const QMqttTopicName &name, size_t seed)
size_t	qHash(const QOcspResponse &key, size_t seed)
size_t	qHash(const QGeoCoordinate &coordinate, size_t seed)
size_t	qHash(ushort key, size_t seed = 0)
`(since 6.0)` size_t	qHash(wchar_t key, size_t seed = 0)
size_t	qHash(QLatin1StringView key, size_t seed = 0)
size_t	qHash(const QSslCertificate &key, size_t seed)
`(since 6.0)` size_t	qHash(QPoint key, size_t seed = 0)
size_t	qHash(const QSslError &key, size_t seed)
size_t	qHash(QTime key, size_t seed = 0)
size_t	qHash(char key, size_t seed = 0)
`(since 6.0)` size_t	qHash(char16_t key, size_t seed = 0)
`(since 6.0)` size_t	qHash(char32_t key, size_t seed = 0)
`(since 6.0)` size_t	qHash(char8_t key, size_t seed = 0)
size_t	qHash(const QBitArray &key, size_t seed = 0)
size_t	qHash(const QByteArray &key, size_t seed = 0)
size_t	qHash(const QChar key, size_t seed = 0)
size_t	qHash(const QDateTime &key, size_t seed = 0)
size_t	qHash(const QHash<Key, T> &key, size_t seed = 0)
size_t	qHash(const QSet<T> &key, size_t seed = 0)
size_t	qHash(const QString &key, size_t seed = 0)
`(since 6.0)` size_t	qHash(const QTypeRevision &key, size_t seed = 0)
size_t	qHash(const QUrl &key, size_t seed = 0)
size_t	qHash(const QVersionNumber &key, size_t seed = 0)
size_t	qHash(const T *key, size_t seed = 0)
size_t	qHash(const std::pair<T1, T2> &key, size_t seed = 0)
size_t	qHash(double key, size_t seed = 0)
size_t	qHash(float key, size_t seed = 0)
size_t	qHash(int key, size_t seed = 0)
size_t	qHash(long key, size_t seed = 0)
size_t	qHash(long double key, size_t seed = 0)
`(since 6.8)` size_t	qHash(qint128 key, size_t seed = 0)
size_t	qHash(qint64 key, size_t seed = 0)
`(since 6.8)` size_t	qHash(quint128 key, size_t seed = 0)
size_t	qHash(quint64 key, size_t seed = 0)
size_t	qHash(short key, size_t seed = 0)
size_t	qHash(signed char key, size_t seed = 0)
`(since 6.0)` size_t	qHash(std::nullptr_t key, size_t seed = 0)
size_t	qHash(uchar key, size_t seed = 0)
size_t	qHash(uint key, size_t seed = 0)
size_t	qHash(ulong key, size_t seed = 0)
size_t	qHashBits(const void p, size_t len, size_t seed* = 0)
`(since 6.0)` size_t	qHashMulti(size_t seed, const T &... args)
`(since 6.0)` size_t	qHashMultiCommutative(size_t seed, const T &... args)
size_t	qHashRange(InputIterator first, InputIterator last, size_t seed = 0)
size_t	qHashRangeCommutative(InputIterator first, InputIterator last, size_t seed = 0)
QDataStream &	operator<<(QDataStream &out, const QHash<Key, T> &hash)
QDataStream &	operator>>(QDataStream &in, QHash<Key, T> &hash)

詳細説明

QHash<Key, T> は Qt の汎用コンテナクラスのひとつです。(キー、値) のペアを格納し、キーに関連付けられた値を非常に高速に検索することができます。

QHash はQMap とよく似た機能を提供します：

QHash はQMap よりも高速なルックアップを提供する（詳細はアルゴリズム複雑度を参照）。
QMap 、項目は常にキーでソートされる。QHashでは、項目は任意に並べ替えられる。
QMap のキー型は operator<() を提供しなければならない。QHashのキー・タイプはoperator==()とqHash() (qHash を参照)というグローバル・ハッシュ関数を提供しなければなりません。

以下は、QString キーとint 値を持つ QHash の例です：

QHash<QString, int> hash;

ハッシュに（キーと値の）ペアを挿入するには、 operator[]() を使用します：

hash["one"] = 1;
hash["three"] = 3;
hash["seven"] = 7;

これは、次の3つの（キー、値）ペアをQHashに挿入します：（"one"、1）、（"three"、3）、（"seven"、7）。ハッシュに項目を挿入するもう1つの方法は、insert （）を使用することです：

hash.insert("twelve", 12);

値を検索するには、operator[]()またはvalue()を使用する：

int num1 = hash["thirteen"];
int num2 = hash.value("thirteen");

ハッシュの中に指定したキーを持つ項目がない場合、これらの関数はデフォルトの値を返します。

ハッシュに特定のキーが含まれているかどうかを調べたい場合は、contains （）を使用します：

int timeout = 30;
if (hash.contains("TIMEOUT"))
    timeout = hash.value("TIMEOUT");

また、value()オーバーロードもあり、指定されたキーを持つ項目がない場合、第2引数をデフォルト値として使用する：

int timeout = hash.value("TIMEOUT", 30);

一般的に、ハッシュ内のキーを検索するには operator[]() よりもcontains() や value() を使うことを推奨します。その理由は、operator[]() は、同じキーを持つ項目が存在しない場合 (ハッシュが 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はハッシュ・テーブルを使って検索を行います。このハッシュ・テーブルは、メモリをあまり浪費せずに高速な検索を行うために自動的に大きくなります。QHashに含まれるアイテムの数がおおよそわかっている場合は、reserve （）を呼び出してハッシュ・テーブルのサイズを制御することもできますが、優れたパフォーマンスを得るためには必要ありません。また、capacity() を呼び出して、ハッシュ・テーブルのサイズを取得することもできる。

テーブルから項目が削除されても、QHashは自動的に縮小しません。ハッシュが使用するメモリを最小限にするには、squeeze() を呼び出します。

QHashに格納されているすべての（キーと値の）ペアをナビゲートしたい場合は、イテレータを使用します。QHashには、Javaスタイルのイテレータ（QHashIterator とQMutableHashIterator ）と、STLスタイルのイテレータ（QHash::const_iterator とQHash::iterator ）があります。ここでは、Javaスタイルのイテレータを使用してQHash<QString, int>を反復処理する方法を示します：

QHashIterator<QString, int> i(hash);
while (i.hasNext()) {
    i.next();
    cout << qPrintable(i.key()) << ": " << i.value() << endl;
}

以下は同じコードだが、STLスタイルのイテレータを使用している：

for (auto i = hash.cbegin(), end = hash.cend(); i != end; ++i)
    cout << qPrintable(i.key()) << ": " << i.value() << endl;

QHashは順序を持たないので、イテレータの順序は予測可能であるとは仮定できません。キーによる順序付けが必要な場合は、QMap.

QHashでは、1つのキーに対して1つの値しか指定できません。QHash 内に既に存在するキーでinsert() を呼び出すと、前の値は消去されます。例えば

hash.insert("plenty", 100);
hash.insert("plenty", 2000);
// hash.value("plenty") == 2000

同じキーの複数のエントリをハッシュ・テーブルに格納する必要がある場合は、QMultiHash.

キーではなく）ハッシュから値だけを取り出す必要がある場合は、範囲ベースのforを使うこともできます：

QHash<QString, int> hash;
...
for (int value : std::as_const(hash))
    cout << value << endl;

ハッシュから項目を削除するにはいくつかの方法がある。ひとつはremove() をコールする方法。これは、指定したキーを持つ項目をすべて削除します。もうひとつの方法は、QMutableHashIterator::remove() を使うことである。さらに、clear() を使用してハッシュ全体を消去することもできる。

QHashのキーと値のデータ型は、割り当て可能なデータ型でなければなりません。例えば、QWidget を値として格納することはできません。代わりに、QWidget * を格納します。

ハッシュ関数

QHashのキー型には、代入可能なデータ型であること以外に、さらに必要な条件があります。それは、operator==()を提供すること、そして、キー型の引数に対してハッシュ値を返すハッシュ関数があることです。

ハッシュ関数は、キーに基づいて数値を計算する。ハッシュ関数は、同じ引数が与えられた場合に常に同じ値を返すのであれば、考え得る限りのアルゴリズムを使用することができる。言い換えれば、もしe1 == e2 、hash(e1) == hash(e2) も同様に成立しなければならない。しかし、良い性能を得るためには、ハッシュ関数は可能な限り異なるキーに対して異なるハッシュ値を返すようにすべきである。

キー・タイプK に対するハッシュ関数は、2つの異なる方法で提供される。

最初の方法は、K の名前空間にqHash() のオーバーロードを持つことである。qHash() 関数は、以下のシグネチャのいずれかを持たなければならない：

size_tqHash(K key,size_t seed)；size_t qHash(const K &key, size_t seed);

size_t qHash(K key);        // deprecated, do not use
size_t qHash(const K &key); // deprecated, do not use

2つの引数のオーバーロードは、ハッシュ関数の計算の種となる符号なし整数を取る。このシードは、algorithmic complexity attacks のファミリーを防ぐために QHash によって提供されます。

注: Qt 6 では、引数を 1 つだけ取るqHash() オーバーロードを定義することができました。Qt 7 からは、2 つの引数を取るオーバーロードを使用することが必須となります。キータイプに対して1つの引数と2つの引数のオーバーロードの両方が定義されている場合、QHashでは後者が使用されます（2つの引数のバージョンを定義し、seedパラメータにデフォルト値を使用することもできます）。

ハッシュ関数を提供する2つ目の方法は、std::hash クラスをキー・タイプK 用に特殊化し、それに適した関数呼び出し演算子を提供することである：

namespace std {
template <> struct hash<K>
{
    // seed is optional
    size_t operator()(const K &key, size_t seed = 0) const;
};
}

seed引数はqHash() と同じ意味を持ち、省略することもできる。

この2番目の方法によって、QHashとC++標準ライブラリの順序なし連想コンテナの間で同じハッシュ関数を再利用することができます。ある型に対してqHash() オーバーロードとstd::hash 特殊化の両方が提供されている場合は、qHash() オーバーロードが優先されます。

以下は、QHash のキーとして使用できる C++ 型と Qt 型の一部のリストです：任意の整数型（char、unsigned long など）、任意のポインタ型、QChar 、QString 、QByteArray 。これらすべてについて、<QHash> ヘッダーは、適切なハッシュ値を計算するqHash() 関数を定義しています。他の多くのQtクラスも、その型に対してqHash のオーバーロードを宣言しています。各クラスのドキュメントを参照してください。

各クラスのドキュメントを参照してください。キーとして他の型を使用したい場合は、operator==()とハッシュの実装を提供していることを確認してください。

便利なqHashMulti() 関数を使用すると、カスタム型に対して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 size_t qHash(const Employee &key, size_t seed)
{
    return qHashMulti(seed, key.name(), key.dateOfBirth());
}

#endif // EMPLOYEE_H

上記の例では、従業員の名前と生年月日のハッシュ値を得るために、QString とQDate に対して、Qt 独自の実装であるqHash() を使用しています。

Qt が提供するqHash() オーバーロードの実装は、いつでも変更される可能性があることに注意してください。Qtのバージョンが異なっても、qHash （）が（同じ入力に対して）同じ結果を与えるという事実を鵜呑みにしてはいけません。

アルゴリズム複雑性攻撃

攻撃者は、ハッシュ・テーブルの同じバケットにハッシュされる（あるいは全く同じハッシュ値を持つ）異なるキーのセットを注意深く事前に計算します。この攻撃は、テーブルにデータが投入されたときに、最悪のケースのアルゴリズム動作（償却されたO(1)ではなくO(n)、詳細はアルゴリズム複雑度を参照）を得ることを目的としている。

この最悪のケースの挙動を回避するために、qHash()によるハッシュ値の計算をランダムなシードでソルトすることができる。このシードはQHashによってプロセスごとに1回自動的に生成され、qHash （）関数の2引数オーバーロードの第2引数としてQHashによって渡される。

QHashのこのランダム化はデフォルトで有効になっている。プログラムは特定のQHash順序に依存すべきではありませんが、デバッグやリグレッション・テストのためなど、一時的に決定論的な動作が必要になる場合があります。ランダム化を無効にするには、環境変数QT_HASH_SEED の値が0になるように定義します。あるいは、QHashSeed::setDeterministicGlobalSeed() 関数を呼び出すこともできる。

QHashIterator 、QMutableHashIterator 、QMap 、QSetも参照のこと。

メンバー型ドキュメント

QHash::ConstIterator

Qt-style synonym forQHash::const_iterator.

QHash::Iterator

Qt-style synonym forQHash::iterator.

QHash::const_key_value_iterator

QHash::const_key_value_iterator typedef は、QHash に対する STL スタイルの const イテレータを提供する。

QHash::const_key_value_iterator はQHash::const_iterator と本質的に同じですが、 operator*() が値の代わりにキーと値のペアを返す点が異なります。

QKeyValueIteratorも参照してください。

`[alias]` QHash::difference_type

ptrdiff_tの型定義。STL との互換性のために提供される。

`[alias]` QHash::key_type

Keyの型定義。STL との互換性のために提供される。

QHash::key_value_iterator

QHash::key_value_iterator typedef は、QHash に対する STL スタイルのイテレータを提供する。

QHash::key_value_iterator は基本的にQHash::iterator と同じですが、 operator*() が値の代わりにキーと値のペアを返す点が異なります。

QKeyValueIteratorも参照してください。

`[alias]` QHash::mapped_type

STL との互換性のために提供される。

`[alias]` QHash::size_type

int の型定義。STL との互換性のために提供される。

メンバ関数ドキュメント

`[noexcept]` T QHash::value(const Key &key) const

`[noexcept]` T QHash::value(const Key &key, const T &defaultValue) const

これはオーバーロードされた関数である。

key に関連付けられた値を返します。

ハッシュにkey の項目がない場合、この関数はdefaultValue を返し、このパラメータが指定されていない場合はデフォルトの値を返します。

`[noexcept]` Key QHash::key(const T &value) const

`[noexcept]` Key QHash::key(const T &value, const Key &defaultKey) const

value にマップされた最初のキーを返す。ハッシュにvalue にマップされた項目がない場合、defaultKey を返し、このパラメータが与えられていない場合はデフォルトで構成されたキーを返す。

QHash の内部データ構造は、値ではなくキーによる高速検索に最適化されているため、この関数は遅い（線形時間）。

`[since 6.4]` auto QHash::asKeyValueRange() &

`[since 6.4]` auto QHash::asKeyValueRange() &&

`[since 6.4]` auto QHash::asKeyValueRange() const &

`[since 6.4]` auto QHash::asKeyValueRange() const &&

このハッシュをキーと値のペアで反復処理できる範囲オブジェクトを返します。例えば、この範囲オブジェクトは、構造化バインディング宣言と組み合わせて、範囲ベースのforループで使用することができます：

QHash<QString, int> hash;
hash.insert("January", 1);
hash.insert("February", 2);
// ...
hash.insert("December", 12);

for (auto [key, value] : hash.asKeyValueRange()) {
    cout << qPrintable(key) << ": " << value << endl;
    --value; // convert to JS month indexing
}

このようにして得られるキーと値は、どちらもハッシュ内のものへの参照であることに注意してください。具体的には、値を変更するとハッシュ自体が変更されます。

警告返されたイテレータや参照は、次にハッシュに対してconstでない関数を呼び出したとき、またはハッシュが破棄されたときに無効になると考えてください。

この関数はQt 6.4で導入されました。

QKeyValueIteratorも参照してください。

template <typename... Args> QHash<Key, T>::iterator QHash::emplace(Key &&key, Args &&... args)

template <typename... Args> QHash<Key, T>::iterator QHash::emplace(const Key &key, Args &&... args)

コンテナに新しい要素を挿入する。この新しい要素は、args を引数としてインプレースで構築されます。

新しい要素を指すイテレータを返します。

警告： 返されたイテレータ/参照は、次にハッシュに対して非定数関数を呼び出したとき、またはハッシュが破棄されたときには無効になっていると考えるべきです。

`[noexcept]` QHash::QHash()

空のハッシュを構築します。

clear()も参照ください 。

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

イニシャライザーリストlist の各要素のコピーでハッシュを構築する。

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

イテレータ範囲 [begin,end] 内の各要素のコピーでハッシュを構築します。範囲によって反復される要素は、first とsecond のデータ・メンバを持つオブジェクト（std::pair のようなもの）で、それぞれKey とT に変換可能でなければなりません。あるいは、反復子はkey() とvalue() のメンバ関数を持ち、それぞれKey に変換可能なキーとT に変換可能な値を返さなければなりません。

`[noexcept]` QHash::QHash(const QHash<Key, T> &other)

other のコピーを構築する。

QHashは暗黙的に共有されるため、この操作は一定時間で行われる。これにより、関数からQHashを返すのが非常に高速になります。共有インスタンスが変更された場合、そのインスタンスはコピーされます（コピーオンライト）。

operator=()も参照してください 。

`[noexcept]` QHash::QHash(QHash<Key, T> &&other)

Move-QHashインスタンスを構築し、other が指していたのと同じオブジェクトを指すようにする。

QHash::~QHash()

ハッシュを破棄する。ハッシュ内の値への参照と、このハッシュのすべてのイテレータは無効になります。

QHash<Key, T>::iterator QHash::begin()

ハッシュの最初の項目を指すSTL 形式のイテレータを返します。

警告返されたイテレータ/参照は、次にハッシュに対して非定数関数を呼び出すか、ハッシュが破棄された時点で無効となることを考慮する必要があります。

constBegin() およびend()も参照 。

`[noexcept]` QHash<Key, T>::const_iterator QHash::begin() const

これはオーバーロードされた関数です。

警告返されたイテレータや参照は、次にそのハッシュに対して非定数関数を呼び出したとき、あるいはハッシュが破棄されたときに無効化されると考えるべきです。

`[noexcept]` qsizetype QHash::capacity() const

QHash'の内部ハッシュテーブルのバケット数を返す。

この関数の唯一の目的は、QHash'のメモリ使用量を微調整する手段を提供することである。一般に、この関数を呼ぶ必要はほとんどないだろう。ハッシュ内の項目数を知りたい場合は、size() を呼び出す。

reserve() およびsqueeze()も参照 。

`[noexcept]` QHash<Key, T>::const_iterator QHash::cbegin() const

ハッシュの最初の項目を指す、STL 形式のイテレータを返します。

警告返されたイテレータ/参照は、次にハッシュに対して const でない関数を呼び出したとき、あるいはハッシュが破棄されたときに無効となります。

begin() およびcend()も参照 。

`[noexcept]` QHash<Key, T>::const_iterator QHash::cend() const

ハッシュの最後の項目の後にある架空の項目を指す、STL 形式のイテレータを返します。

警告返されたイテレータ/参照は、次にハッシュに対してconstでない関数を呼び出したとき、またはハッシュが破棄されたときに無効になると考えるべきです。

cbegin() およびend()も参照のこと 。

`[noexcept(...)]` void QHash::clear()

ハッシュからすべての項目を削除し、ハッシュが使用していたすべてのメモリを解放する。

注意: std::is_nothrow_destructible<Node>::value がtrue のとき、この関数は noexcept となる。

remove()も参照のこと 。

`[noexcept]` QHash<Key, T>::const_iterator QHash::constBegin() const

ハッシュの最初の項目を指す、STL 形式のイテレータを返します。

警告返されたイテレータ/参照は、次にハッシュに対して const でない関数を呼び出したとき、あるいはハッシュが破棄されたときに無効となります。

begin() およびconstEnd()も参照 。

`[noexcept]` QHash<Key, T>::const_iterator QHash::constEnd() const

ハッシュの最後の項目の後にある架空の項目を指す、STL 形式のイテレータを返します。

constBegin() およびend()も参照のこと 。

`[noexcept]` QHash<Key, T>::const_iterator QHash::constFind(const Key &key) const

ハッシュ内のkey を持つ項目を指すイテレータを返す。

ハッシュにkey を持つ項目がない場合、この関数はconstEnd() を返します。

警告： 返されたイテレータ/参照は、次にハッシュに対して非定数関数を呼び出したとき、またはハッシュが破棄されたときに無効となります。

find()も参照のこと 。

`[noexcept]` QHash<Key, T>::const_key_value_iterator QHash::constKeyValueBegin() const

ハッシュの最初のエントリを指す、STL 形式のイテレータを返します。

警告返されたイテレータや参照は、次にそのハッシュに対して const でない関数をコールしたとき、あるいはハッシュが破棄されたときに無効となります。

keyValueBegin()も参照 。

`[noexcept]` QHash<Key, T>::const_key_value_iterator QHash::constKeyValueEnd() const

ハッシュの最後のエントリの後の架空のエントリを指す、STL 形式のイテレータを返します。

警告返されたイテレータや参照は、次にハッシュに対して const でない関数をコールしたとき、あるいはハッシュが破棄されたときに無効となります。

constKeyValueBegin()も参照 。

`[noexcept]` bool QHash::contains(const Key &key) const

ハッシュにkey の項目があればtrue を返し、なければfalse を返す。

count()も参照のこと 。

`[noexcept]` qsizetype QHash::count(const Key &key) const

key に関連付けられた項目の数を返す。

contains()も参照 。

`[noexcept]` qsizetype QHash::count() const

これはオーバーロードされた関数である。

size() と同じ。

`[noexcept]` bool QHash::empty() const

この関数はSTLとの互換性のために提供されている。これはisEmpty() と等価であり、ハッシュが空の場合は真を返し、そうでない場合はfalse を返します。

`[noexcept]` QHash<Key, T>::iterator QHash::end()

ハッシュの最後の項目の後にある架空の項目を指すSTL 形式のイテレータを返します。

警告返されたイテレータ/参照は、次にハッシュに対して非定数関数を呼び出したとき、あるいはハッシュが破棄されたときに無効となります。

begin() およびconstEnd()も参照のこと 。

`[noexcept]` QHash<Key, T>::const_iterator QHash::end() const

これはオーバーロードされた関数です。

QHash<Key, T>::iterator QHash::erase(QHash<Key, T>::const_iterator pos)

イテレータpos に関連付けられた (key, value) ペアをハッシュから削除し、ハッシュの次の項目へのイテレータを返します。

この関数は、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;
    }
}

警告： 警告：返されたイテレータや参照は、次にハッシュに対して非定数関数を呼び出すか、ハッシュが破棄されたときに無効化されると考えてください。

remove()、take()、find()も参照のこと 。

QHash<Key, T>::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;
}

警告警告：返されたイテレータや参照は、次にハッシュに対してconstでない関数を呼び出したとき、あるいはハッシュが破棄されたときに無効になると考えてください。

value()およびvalues()も参照 。

`[noexcept]` QHash<Key, T>::const_iterator QHash::find(const Key &key) const

これはオーバーロードされた関数です。

void QHash::insert(const QHash<Key, T> &other)

other ハッシュの全アイテムをこのハッシュに挿入する。

キーが両方のハッシュに共通する場合、その値はother に格納されている値に置き換えられます。

QHash<Key, T>::iterator QHash::insert(const Key &key, const T &value)

key と値value を持つ新しい項目を挿入する。

すでにkey を持つ項目がある場合、その項目の値はvalue に置き換えられます。

新しい/更新された要素を指すイテレータを返します。

警告返されたイテレータ/参照は、次にハッシュに対して非定数関数を呼び出したとき、またはハッシュが破棄されたときには無効になっていると考えるべきです。

`[noexcept]` bool QHash::isEmpty() const

ハッシュに項目がない場合はtrue を返し、そうでない場合は false を返す。

size()も参照 ください。

`[noexcept]` QHash<Key, T>::key_iterator QHash::keyBegin() const

ハッシュの最初のキーを指す、STL 形式のイテレータを返します。

警告返されたイテレータや参照は、次にハッシュに対して const でない関数を呼び出したとき、あるいはハッシュが破棄されたときに無効となります。

keyEnd()も参照 。

`[noexcept]` QHash<Key, T>::key_iterator QHash::keyEnd() const

ハッシュの最後のキーに続く架空の項目を指す、STL 形式のイテレータを返します。

keyBegin()も参照 。

QHash<Key, T>::key_value_iterator QHash::keyValueBegin()

ハッシュの最初のエントリを指すSTL 形式のイテレータを返します。

警告返されたイテレータや参照は、次にハッシュに対して非定数関数を呼び出したとき、あるいはハッシュが破棄されたときに無効となります。

keyValueEnd()も参照 。

`[noexcept]` QHash<Key, T>::const_key_value_iterator QHash::keyValueBegin() const

ハッシュの最初のエントリを指す、STL 形式のイテレータを返します。

keyValueEnd()も参照 。

QHash<Key, T>::key_value_iterator QHash::keyValueEnd()

ハッシュの最後のエントリの後の架空のエントリを指すSTL 形式のイテレータを返します。

keyValueBegin()も参照 。

`[noexcept]` QHash<Key, T>::const_key_value_iterator QHash::keyValueEnd() const

ハッシュの最後のエントリの後の架空のエントリを指す、STL 形式のイテレータを返します。

keyValueBegin()も参照 。

QList<Key> QHash::keys() const

ハッシュ内のすべてのキーを任意の順番で含むリストを返す。

この順序は、values() で使用したものと同じであることが保証される。

この関数は、線形時間で新しいリストを作成します。keyBegin() からkeyEnd() を繰り返し実行することで、時間とメモリの浪費を避けることができる。

values() およびkey()も参照の こと。

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

これはオーバーロードされた関数である。

値value に関連付けられたすべてのキーを任意の順序で含むリストを返す。

QHash の内部データ構造は、値ではなくキーによる高速検索に最適化されているため、この関数は遅い（線形時間）ことがある。

`[noexcept]` float QHash::load_factor() const

QHash の内部ハッシュテーブルの現在の負荷率を返す。これはcapacity()/size() と同じである。使用する実装では、負荷率を 0.25 から 0.5 の間に保つようにします。これにより、ハッシュ・テーブルの衝突が多すぎてパフォーマンスが低下するのを避けることができる。

ロードファクターが低くても、ハッシュテーブルの実装のメモリーオーバーヘッドは非常に低い。

このメソッドは純粋に診断のために存在するものであり、自分で呼び出す必要はほとんどないはずである。

reserve() およびsqueeze()も参照の こと。

bool QHash::remove(const Key &key)

ハッシュからkey を持つ項目を削除します。そのキーがハッシュに存在し、かつその項目が削除されている場合は true を返し、そうでない場合は false を返します。

clear() およびtake()も参照 ください。

`[since 6.1]` template <typename Predicate> qsizetype QHash::removeIf(Predicate pred)

述語pred が真を返す全ての要素をハッシュから削除する。

この関数は、QHash<Key, T>::iterator 型の引数か、std::pair<const Key &, T &> 型の引数を取る述語をサポートします。

もしあれば、削除された要素の数を返します。

この関数はQt 6.1で導入されました。

clear() とtake()も参照してください 。

void QHash::reserve(qsizetype size)

QHash の内部ハッシュテーブルが、ハッシュテーブルを成長させることなく、少なくともsize アイテムを格納するスペースを持っていることを保証する。

これは、良好なパフォーマンスを保証するために、ハッシュテーブルが少なくとも2 *size のバケットを含むことを意味する。

この関数は、巨大なハッシュを構築する必要があり、再割り当ての繰り返しを避けたいコードに便利です。例えば

QHash<QString, int> hash;
hash.reserve(20000);
for (int i = 0; i < 20000; ++i)
    hash.insert(keys[i], values[i]);

理想的には、size がハッシュ内に予想される項目の最大数であるべきです。QHash は、内部ハッシュテーブルを大きくすることなく、size 項目をテーブルに格納できる、可能な限り小さなバケット数を選択します。size が過小評価であった場合、QHash が少し遅くなるという最悪の事態が起こる。

一般的には、この関数を呼び出す必要はほとんどないだろう。QHash'sの内部ハッシュ・テーブルは、メモリをあまり浪費することなく、良好なパフォーマンスを提供するように自動的に成長する。

squeeze() およびcapacity()も参照の こと。

`[noexcept]` qsizetype QHash::size() const

ハッシュ内の項目の数を返します。

isEmpty() およびcount()も参照 ください。

void QHash::squeeze()

QHash'の内部ハッシュテーブルのサイズを縮小してメモリを節約する。

この関数の唯一の目的は、QHash'のメモリ使用量を微調整する手段を提供することである。一般に、この関数を呼び出す必要はほとんどない。

reserve() およびcapacity()も参照 。

`[noexcept]` void QHash::swap(QHash<Key, T> &other)

このハッシュをother と交換する。この操作は非常に高速で、失敗することはない。

T QHash::take(const Key &key)

ハッシュからkey の項目を削除し、その項目に関連付けられた値を返します。

その項目がハッシュに存在しない場合、この関数は単にデフォルトの値を返します。

戻り値を使用しない場合は、remove() の方が効率的です。

remove()も参照 。

QList<T> QHash::values() const

ハッシュ内のすべての値を任意の順番で含むリストを返す。

この順序は、keys() で使用される順序と同じであることが保証される。

この関数は、線形時間で新しいリストを作成します。keyValueBegin() からkeyValueEnd() を繰り返し実行することで、時間とメモリの浪費を避けることができる。

keys() およびvalue()も参照の こと。

bool QHash::operator!=(const QHash<Key, T> &other) const

other がこのハッシュと等しくない場合はtrue を返し、そうでない場合はfalse を返す。

2つのハッシュが同じ（キー、値）ペアを含む場合、等しいとみなされる。

この関数は、operator==() を実装する値型を必要とします。

operator==()も参照 。

`[noexcept]` QHash<Key, T> &QHash::operator=(QHash<Key, T> &&other)

Move-other をこのQHash インスタンスに割り当てる。

`[noexcept(...)]` QHash<Key, T> &QHash::operator=(const QHash<Key, T> &other)

other をこのハッシュに割り当て、このハッシュへの参照を返す。

注意： この関数は、std::is_nothrow_destructible<Node>::value がtrue の場合は noexcept となる。

bool QHash::operator==(const QHash<Key, T> &other) const

other がこのハッシュと等しい場合はtrue を返し、そうでない場合は false を返します。

2つのハッシュが同じ（キー、値）ペアを含む場合、等しいとみなされる。

この関数は、operator==() を実装する値型を必要とします。

operator!=()も参照 。

T &QHash::operator[](const Key &key)

key に関連付けられた値を変更可能な参照として返す。

ハッシュにkey の項目がない場合、この関数はデフォルトで構成された値を key のハッシュに挿入し、その参照を返します。

警告返されたイテレータ/参照は、次にハッシュに対してconstでない関数を呼び出したとき、またはハッシュが破棄されたときには無効になっていると考えるべきです。

insert() およびvalue()も参照のこと 。

`[noexcept]` const T QHash::operator[](const Key &key) const

これはオーバーロードされた関数である。

value()と同じ。

関連する非会員

`[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以前では、非スコープの列挙型は、その基礎となる整数型への暗黙の変換のため、この関数の整数オーバーロードに依存していました。スコープ付き列挙型の場合は、自分でオーバーロードを実装する必要がありました。これは、古い Qt バージョンとの互換性を保つための後方互換性のある修正です。

この関数は Qt 6.5 で導入されました。

`[noexcept]` size_t qHash(QDate 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(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]` 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)

seed を計算の種として、key のハッシュ値を返す。

型Key およびT は qHash() でサポートされていなければならない。

注： noexcept(qHash(std::declval<Key&>())) && noexcept(qHash(std::declval<T&>())) がtrue の場合、この関数は noexcept となる。

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

seed を計算の種として、key のハッシュ値を返す。

T 、qHash()がサポートしていなければならない。

ハッシュ値はkey の要素の順序に依存しない、つまり、同じ要素を含む集合は同じ値にハッシュする。

注： noexcept(qHashRangeCommutative(key.begin(), key.end(), seed)) がtrue の場合、この関数は noexcept となる。

`[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 を使用する。

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

seed を計算の種として、key のハッシュ値を返す。

型T1 およびT2 は qHash() でサポートされていなければならない。

注： QHashPrivate::noexceptPairHash<T1, T2>() がtrue の場合、この関数は noexcept となる。

`[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)

seed を計算のシードとして使用し、key のハッシュ値を返す。

注意: この関数は、ネイティブの 128 ビット整数型をサポートするプラットフォームでのみ利用可能です。

この関数は 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)

seed を計算のシードとして使用し、key のハッシュ値を返す。

注意: この関数は、ネイティブの 128 ビット整数型をサポートするプラットフォームでのみ利用可能です。

この関数は 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 で導入されました。

`[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 を使用する。

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

p seed が指すサイズのメモリ・ブロックのハッシュ値を返す。len

この関数は、独自のカスタム型に対して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() を順次適用し、ハッシュ値を1つにまとめる。

引数の順番は重要であることに注意。順番が重要でない場合は、代わりにqHashMultiCommutative() を使用する。生メモリをハッシュする場合はqHashBits()を使用し、範囲をハッシュする場合はqHashRange()を使用する。

この関数は、qHash() を独自のカスタム・タイプ用に実装するための便宜として提供されている。例えば、クラスEmployee に対して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 size_t qHash(const Employee &key, size_t seed)
{
    return qHashMulti(seed, key.name(), key.dateOfBirth());
}

#endif // EMPLOYEE_H

この関数は Qt 6.0 で導入されました。

注意: std::conjunction_v<QtPrivate::QNothrowHashable<T>...> がtrue の場合、この関数は noexcept となります。

qHashMultiCommutative とqHashRangeも参照してください。

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

args のハッシュ値を返す。計算のシードとしてseed を使用し、各要素にqHash() を順次適用し、ハッシュ値を1つにまとめる。

引数の順番は重要ではない。順番が重要な場合は、qHashMulti() を代わりに使用する。生メモリをハッシュする場合はqHashBits() を、範囲をハッシュする場合はqHashRange() を使用する。

この関数は、独自のカスタム・タイプ用にqHash() を実装するための便宜として提供されています。

この関数は Qt 6.0 で導入されました。

注意: std::conjunction_v<QtPrivate::QNothrowHashable<T>...> がtrue の場合、この関数は noexcept となります。

qHashMulti およびqHashRangeも参照してください。

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

範囲 [first,last] のハッシュ値を返します。計算の種としてseed を使用し、各要素にqHash() を順次適用してハッシュ値を1つにまとめます。

この関数の返り値は、範囲内の要素の順番に依存します。つまり

{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() のオーバーロードと同様に、いつでも変更される可能性があることは、繰り返し述べておきます。Qt の異なるバージョン間で qHashRange() が（同じ入力に対して）同じ結果を返すという事実は、たとえ要素の型に対してqHash() がそうであったとしても、当てにしてはいけません。

注意: noexcept(qHash(*first)) がtrue の場合、この関数は noexcept となります。

qHashBits() およびqHashRangeCommutative()も参照してください 。

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

範囲 [first,last] のハッシュ値を返します。計算の種としてseed を使用し、各要素にqHash() を順次適用してハッシュ値を1つにまとめます。

この関数の返り値は、範囲内の要素の順序には依存しません。つまり

{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 が提供するqHash() のオーバーロードと同様に、いつでも変更される可能性があります。Qt の異なるバージョン間で qHashRangeCommutative() が（同じ入力に対して）同じ結果を返すという事実は、要素タイプに対するqHash() がそうであったとしても、当てにしてはいけません。

注意: noexcept(qHash(*first)) がtrue の場合、この関数は noexcept となります。

qHashBits() およびqHashRange()も参照してください 。

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

ハッシュhash をストリームout に書き込む。

この関数は、キー型と値型を実装する必要がありますoperator<<() 。

Qt データ型のシリアライズ」も参照してください 。

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

ストリームin からハッシュをhash に読み込む。

この関数は、operator>>() を実装するためのキーと値の型を必要とします。

Qt データ型のシリアライズ」も参照してください 。

© 2025 The Qt Company Ltd. Documentation contributions included herein are the copyrights of their respective owners. The documentation provided herein is licensed under the terms of the GNU Free Documentation License version 1.3 as published by the Free Software Foundation. Qt and respective logos are trademarks of The Qt Company Ltd. in Finland and/or other countries worldwide. All other trademarks are property of their respective owners.

QHash Class

パブリック型

パブリック関数

関連する非メンバ

詳細説明

ハッシュ関数

アルゴリズム複雑性攻撃

メンバー型ドキュメント

QHash::ConstIterator

QHash::Iterator

QHash::const_key_value_iterator

[alias] QHash::difference_type

[alias] QHash::key_type

QHash::key_value_iterator

[alias] QHash::mapped_type

[alias] QHash::size_type

メンバ関数ドキュメント

[noexcept] T QHash::value(const Key &key) const

[noexcept] T QHash::value(const Key &key, const T &defaultValue) const

[noexcept] Key QHash::key(const T &value) const

[noexcept] Key QHash::key(const T &value, const Key &defaultKey) const

[since 6.4] auto QHash::asKeyValueRange() &

[since 6.4] auto QHash::asKeyValueRange() &&

[since 6.4] auto QHash::asKeyValueRange() const &

[since 6.4] auto QHash::asKeyValueRange() const &&

template <typename... Args> QHash<Key, T>::iterator QHash::emplace(Key &&key, Args &&... args)

template <typename... Args> QHash<Key, T>::iterator QHash::emplace(const Key &key, Args &&... args)

[noexcept] QHash::QHash()

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

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

[noexcept] QHash::QHash(const QHash<Key, T> &other)

[noexcept] QHash::QHash(QHash<Key, T> &&other)

QHash::~QHash()

QHash<Key, T>::iterator QHash::begin()

[noexcept] QHash<Key, T>::const_iterator QHash::begin() const

[noexcept] qsizetype QHash::capacity() const

[noexcept] QHash<Key, T>::const_iterator QHash::cbegin() const

[noexcept] QHash<Key, T>::const_iterator QHash::cend() const

[noexcept(...)] void QHash::clear()

[noexcept] QHash<Key, T>::const_iterator QHash::constBegin() const

[noexcept] QHash<Key, T>::const_iterator QHash::constEnd() const

[noexcept] QHash<Key, T>::const_iterator QHash::constFind(const Key &key) const

[noexcept] QHash<Key, T>::const_key_value_iterator QHash::constKeyValueBegin() const

[noexcept] QHash<Key, T>::const_key_value_iterator QHash::constKeyValueEnd() const

[noexcept] bool QHash::contains(const Key &key) const

[noexcept] qsizetype QHash::count(const Key &key) const

[noexcept] qsizetype QHash::count() const

[noexcept] bool QHash::empty() const

[noexcept] QHash<Key, T>::iterator QHash::end()

[noexcept] QHash<Key, T>::const_iterator QHash::end() const

QHash<Key, T>::iterator QHash::erase(QHash<Key, T>::const_iterator pos)

QHash<Key, T>::iterator QHash::find(const Key &key)

[noexcept] QHash<Key, T>::const_iterator QHash::find(const Key &key) const

void QHash::insert(const QHash<Key, T> &other)

QHash<Key, T>::iterator QHash::insert(const Key &key, const T &value)

[noexcept] bool QHash::isEmpty() const

[noexcept] QHash<Key, T>::key_iterator QHash::keyBegin() const

[noexcept] QHash<Key, T>::key_iterator QHash::keyEnd() const

QHash<Key, T>::key_value_iterator QHash::keyValueBegin()

[noexcept] QHash<Key, T>::const_key_value_iterator QHash::keyValueBegin() const

QHash<Key, T>::key_value_iterator QHash::keyValueEnd()

[noexcept] QHash<Key, T>::const_key_value_iterator QHash::keyValueEnd() const

QList<Key> QHash::keys() const

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

[noexcept] float QHash::load_factor() const

bool QHash::remove(const Key &key)

[since 6.1] template <typename Predicate> qsizetype QHash::removeIf(Predicate pred)

void QHash::reserve(qsizetype size)

[noexcept] qsizetype QHash::size() const

void QHash::squeeze()

[noexcept] void QHash::swap(QHash<Key, T> &other)

T QHash::take(const Key &key)

QList<T> QHash::values() const

bool QHash::operator!=(const QHash<Key, T> &other) const

[noexcept] QHash<Key, T> &QHash::operator=(QHash<Key, T> &&other)

[noexcept(...)] QHash<Key, T> &QHash::operator=(const QHash<Key, T> &other)

bool QHash::operator==(const QHash<Key, T> &other) const

T &QHash::operator[](const Key &key)

[noexcept] const T QHash::operator[](const Key &key) const

関連する非会員

`[alias]` QHash::difference_type

`[alias]` QHash::key_type

`[alias]` QHash::mapped_type

`[alias]` QHash::size_type

`[noexcept]` T QHash::value(const Key &key) const

`[noexcept]` T QHash::value(const Key &key, const T &defaultValue) const

`[noexcept]` Key QHash::key(const T &value) const

`[noexcept]` Key QHash::key(const T &value, const Key &defaultKey) const

`[since 6.4]` auto QHash::asKeyValueRange() &

`[since 6.4]` auto QHash::asKeyValueRange() &&

`[since 6.4]` auto QHash::asKeyValueRange() const &

`[since 6.4]` auto QHash::asKeyValueRange() const &&

`[noexcept]` QHash::QHash()

`[noexcept]` QHash::QHash(const QHash<Key, T> &other)

`[noexcept]` QHash::QHash(QHash<Key, T> &&other)

`[noexcept]` QHash<Key, T>::const_iterator QHash::begin() const

`[noexcept]` qsizetype QHash::capacity() const

`[noexcept]` QHash<Key, T>::const_iterator QHash::cbegin() const

`[noexcept]` QHash<Key, T>::const_iterator QHash::cend() const

`[noexcept(...)]` void QHash::clear()

`[noexcept]` QHash<Key, T>::const_iterator QHash::constBegin() const

`[noexcept]` QHash<Key, T>::const_iterator QHash::constEnd() const

`[noexcept]` QHash<Key, T>::const_iterator QHash::constFind(const Key &key) const

`[noexcept]` QHash<Key, T>::const_key_value_iterator QHash::constKeyValueBegin() const

`[noexcept]` QHash<Key, T>::const_key_value_iterator QHash::constKeyValueEnd() const

`[noexcept]` bool QHash::contains(const Key &key) const

`[noexcept]` qsizetype QHash::count(const Key &key) const

`[noexcept]` qsizetype QHash::count() const

`[noexcept]` bool QHash::empty() const

`[noexcept]` QHash<Key, T>::iterator QHash::end()

`[noexcept]` QHash<Key, T>::const_iterator QHash::end() const

`[noexcept]` QHash<Key, T>::const_iterator QHash::find(const Key &key) const

`[noexcept]` bool QHash::isEmpty() const

`[noexcept]` QHash<Key, T>::key_iterator QHash::keyBegin() const

`[noexcept]` QHash<Key, T>::key_iterator QHash::keyEnd() const

`[noexcept]` QHash<Key, T>::const_key_value_iterator QHash::keyValueBegin() const

`[noexcept]` QHash<Key, T>::const_key_value_iterator QHash::keyValueEnd() const

`[noexcept]` float QHash::load_factor() const

`[since 6.1]` template <typename Predicate> qsizetype QHash::removeIf(Predicate pred)

`[noexcept]` qsizetype QHash::size() const

`[noexcept]` void QHash::swap(QHash<Key, T> &other)

`[noexcept]` QHash<Key, T> &QHash::operator=(QHash<Key, T> &&other)

`[noexcept(...)]` QHash<Key, T> &QHash::operator=(const QHash<Key, T> &other)

`[noexcept]` const T QHash::operator[](const Key &key) const

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

`[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)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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