QHash Class

template <typename Key, typename T> class QHash

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

Header:	`#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)
size_t	qHash(QDate key, size_t seed = 0)
size_t	qHash(const QMqttTopicFilter &filter, size_t seed)
size_t	qHash(QSslEllipticCurve curve, size_t seed)
size_t	qHash(QLatin1StringView 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 &response, size_t seed)
size_t	qHash(const QGeoCoordinate &coordinate, size_t seed)
`(since 6.0)` size_t	qHash(wchar_t key, size_t seed = 0)
`(since 6.0)` size_t	qHash(QPoint key, size_t seed = 0)
size_t	qHash(const QSslCertificate &key, size_t seed)
size_t	qHash(QTime key, size_t seed = 0)
size_t	qHash(const QSslError &key, size_t seed)
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 &url, 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	qHash(ushort 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）。ハッシュに項目を挿入するもうひとつの方法は、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_t qHash(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

QHash::const_iterator のQt-styleシノニム。

QHash::Iterator

QHash::iterator の Qt 形式のシノニム．

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*() が値の代わりに key/value ペアを返す点が異なります。

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

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

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

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

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

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

注意: この関数は、"std::is_nothrow_destructible<Node>::value" が真であっても例外をスローしません。

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

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

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

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

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

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

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

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

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

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

keyValueBegin()も参照 。

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

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

警告返されたイテレータや参照は、次にハッシュに対して 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

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

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

keyBegin()も参照 。

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

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

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

keyValueEnd()も参照 。

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

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

keyValueEnd()も参照 。

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

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

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

keyValueBegin()も参照 。

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

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

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" が真の場合、例外をスローしません。

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)

この関数は、述語pred が真を返す全ての要素をハッシュhash から削除します。

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

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

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

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

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

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

seed をシードとして、key のハッシュ値を返します。

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

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

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

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

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

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

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

seed をシードとして、key のハッシュ値を返します。

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

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

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

seed をシードとして、key のハッシュ値を返します。

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

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

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

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

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

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

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

注意: この関数は、"noexcept(qHash(std::declar<Key&>()) && noexcept(qHash(std::declval<T&>()))" が真の場合、例外をスローしない。

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

key のハッシュ値を返します。seed を使って計算します。

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

注意： この関数は、"noexcept(qHashRangeCommutative(key.begin(), key.end(), seed))" が真である場合、例外をスローしない。

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

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

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

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

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

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

url のハッシュ値を返します。指定された場合、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)

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

`[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>()" が真の場合、例外をスローしない。

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

`[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>...>"が真である場合、例外をスローしません。

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 の場合、例外をスローしません。

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

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

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

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

{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() が変更されたとしても、qHashRange() が異なる Qt バージョン間で（同じ入力に対して）同じ結果を与えるという事実を鵜呑みにしてはいけません。

注意: この関数は、"noexcept(qHash(*first)) "が真である場合、例外をスローしません。

qHashBits() およびqHashRangeCommutative()も参照 。

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

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

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

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

注意： この関数は "noexcept(qHash(*first)) "が真である場合、例外をスローしません。

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>>() を実装するための key 型と value 型が必要です。

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

©2024 The Qt Company Ltd. 本書に含まれる文書の著作権は、それぞれの所有者に帰属します。本書で提供されるドキュメントは、Free Software Foundation が発行したGNU Free Documentation License version 1.3に基づいてライセンスされています。 Qtおよびそれぞれのロゴは、フィンランドおよびその他の国におけるThe Qt Company Ltd.の商標です。その他すべての商標は、それぞれの所有者に帰属します。

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)

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

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

`[constexpr noexcept, since 6.0]` size_t qHash(wchar_t 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 &url, 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)

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

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