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 의 키 유형은 연산자<()를 제공해야 합니다. QHash의 키 유형은 연산자==() 및 qHash() 라는 전역 해시 함수를 제공해야 합니다( qHash 참조).

다음은 QString 키와 int 값이 있는 QHash 예시입니다:

QHash<QString, int> hash;

해시에 (키, 값) 쌍을 삽입하려면 연산자[]()를 사용할 수 있습니다:

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

이렇게 하면 다음과 같은 세 개의 (키, 값) 쌍이 QHash에 삽입됩니다: ("one", 1), ("three", 3), ("seven", 7). 해시에 항목을 삽입하는 또 다른 방법은 insert()를 사용하는 것입니다:

hash.insert("twelve", 12);

값을 조회하려면 operator[]() 또는 value()를 사용합니다:

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

해시에 지정된 키를 가진 항목이 없는 경우 이 함수는 기본값으로 구성된 값을 반환합니다.

해시에 특정 키가 포함되어 있는지 확인하려면 contains()를 사용합니다:

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

지정된 키를 가진 항목이 없는 경우 두 번째 인수를 기본값으로 사용하는 value() 오버로드도 있습니다:

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

일반적으로 해시에서 키를 조회할 때는 operator[]() 대신 contains() 및 value()를 사용하는 것이 좋습니다. 그 이유는 연산자[]()는 동일한 키를 가진 항목이 없는 경우(해시가 const가 아닌 경우) 자동으로 해시에 항목을 삽입하기 때문입니다. 예를 들어, 다음 코드 조각은 메모리에 1000개의 항목을 생성합니다:

// WRONG
QHash<int, QWidget *> hash;
...
for (int i = 0; i < 1000; ++i) {
    if (hash[i] == okButton)
        cout << "Found button at index " << i << endl;
}

이 문제를 방지하려면 위 코드에서 hash[i] 을 hash.value(i) 으로 바꾸세요.

내부적으로 QHash는 해시 테이블을 사용하여 조회를 수행합니다. 이 해시 테이블은 메모리를 너무 많이 낭비하지 않고 빠른 조회를 제공하기 위해 자동으로 커집니다. 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는 키당 하나의 값만 허용합니다. 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의 키 유형은 할당 가능한 데이터 유형이라는 것 외에 추가 요구 사항이 있는데, 연산자==()를 제공해야 하며 키 유형의 인자에 대한 해시 값을 반환하는 해싱 함수도 있어야 합니다.

해싱 함수는 키를 기반으로 숫자 값을 계산합니다. 동일한 인수가 주어지면 항상 같은 값을 반환하는 한 상상할 수 있는 모든 알고리즘을 사용할 수 있습니다. 즉, e1 == e2 이면 hash(e1) == hash(e2) 도 같아야 합니다. 그러나 좋은 성능을 얻으려면 해싱 함수는 가능한 한 키마다 다른 해시 값을 반환하려고 시도해야 합니다.

키 유형 K 에 대한 해싱 함수는 두 가지 방식으로 제공될 수 있습니다.

첫 번째 방법은 K 의 네임스페이스에 qHash() 의 오버로드를 갖는 것입니다. qHash() 함수에는 이러한 서명 중 하나가 있어야 합니다:

size_t qHash(K 키, size_t 시드);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

두 인자 오버로드는 해시 함수의 계산을 시드하는 데 사용해야 하는 부호 없는 정수를 취합니다. 이 시드는 algorithmic complexity attacks 의 패밀리를 방지하기 위해 QHash에서 제공합니다.

참고: Qt 6에서는 인자를 하나만 받는 qHash() 오버로드를 정의할 수 있지만, 이에 대한 지원은 더 이상 제공되지 않습니다. Qt 7부터는 두 개의 인자를 사용하는 오버로드를 의무적으로 사용해야 합니다. 하나의 키 유형에 대해 하나의 인자와 두 개의 인자 오버로드가 모두 정의된 경우, 후자가 QHash에서 사용됩니다(간단히 두 개의 인자 버전을 정의하고 시드 매개변수에 기본값을 사용할 수 있습니다).

해싱 함수를 제공하는 두 번째 방법은 키 유형 K 에 대해 std::hash 클래스를 특수화하고 이에 적합한 함수 호출 연산자를 제공하는 것입니다:

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

시드 인수는 qHash() 과 동일한 의미를 가지며 생략할 수 있습니다.

이 두 번째 방법은 QHash와 C++ 표준 라이브러리 정렬되지 않은 연관 컨테이너 간에 동일한 해시 함수를 재사용할 수 있게 해줍니다. 한 유형에 대해 qHash() 오버로드와 std::hash 전문화가 모두 제공되는 경우, qHash() 오버로드가 선호됩니다.

다음은 QHash에서 키 역할을 할 수 있는 C++ 및 Qt 타입의 일부 목록입니다: 모든 정수 타입(문자, 부호 없는 긴 등), 모든 포인터 타입, QChar, QString, 그리고 QByteArray. 이 모든 것에 대해 <QHash> 헤더는 적절한 해시 값을 계산하는 qHash() 함수를 정의합니다. 다른 많은 Qt 클래스도 해당 유형에 대해 qHash 오버로드를 선언합니다; 각 클래스의 설명서를 참조하십시오.

다른 타입을 키로 사용하려면 연산자==()와 해시 구현을 제공해야 합니다.

일반적으로 여러 필드에서 해시 값을 생성하려는 사용자 정의 유형에 대해 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 에 대한 qHash()의 자체 구현을 사용하여 각각 직원의 이름과 생년월일에 대한 해시값을 제공했습니다.

Qt에서 제공하는 qHash() 오버로드의 구현은 언제든지 변경될 수 있다는 점에 유의하세요. qHash ()가 여러 Qt 버전에서 동일한 입력에 대해 동일한 결과를 제공한다는 사실에 의존해서는 안 됩니다.

알고리즘 복잡성 공격

모든 해시 테이블은 특정 종류의 서비스 거부 공격에 취약하며, 공격자는 해시 테이블의 동일한 버킷에서 해시될(또는 동일한 해시 값을 갖는) 여러 키 집합을 신중하게 미리 계산합니다. 이 공격은 데이터가 테이블에 입력될 때 최악의 알고리즘 동작(상각된 O(1) 대신 O(n), 자세한 내용은 알고리즘 복잡성 참조)을 얻는 것을 목표로 합니다.

이러한 최악의 동작을 피하기 위해 qHash()에서 수행하는 해시 값 계산을 임의의 시드로 소금에 절여 공격의 범위를 무효화할 수 있습니다. 이 시드는 프로세스당 한 번씩 QHash에 의해 자동으로 생성된 다음 qHash() 함수의 두 인수 오버로드의 두 번째 인수로 QHash에 의해 전달됩니다.

이 QHash의 무작위화는 기본적으로 활성화되어 있습니다. 프로그램이 특정 QHash 순서에 의존해서는 안 되지만, 디버깅이나 회귀 테스트와 같이 일시적으로 결정론적 동작이 필요한 상황이 있을 수 있습니다. 무작위화를 비활성화하려면 환경 변수 QT_HASH_SEED 값이 0이 되도록 정의하세요. 또는 QHashSeed::setDeterministicGlobalSeed() 함수를 호출할 수 있습니다.

QHashIterator, QMutableHashIterator, QMap, QSet 을참조하세요 .

멤버 유형 문서

QHash::ConstIterator

QHash::const_iterator 의 Qt 스타일 동의어.

QHash::Iterator

QHash::iterator 의 Qt 스타일 동의어.

QHash::const_key_value_iterator

QHash::const_key_value_iterator는 QHash 에 대한 STL 스타일의 const 이터레이터를 제공합니다.

QHash::const_key_value_iterator는 QHash::const_iterator 와 본질적으로 동일하지만, 연산자*()가 값 대신 키/값 쌍을 반환한다는 차이점이 있습니다.

QKeyValueIterator도 참조하세요 .

`[alias]` QHash::difference_type

ptrdiff_t의 경우 Typedef. STL 호환성을 위해 제공됩니다.

`[alias]` QHash::key_type

키에 Typedef. STL 호환성을 위해 제공됩니다.

QHash::key_value_iterator

QHash::키_값_이터레이터는 QHash 에 대한 STL 스타일 이터레이터를 제공합니다.

QHash::key_value_iterator는 QHash::iterator 와 본질적으로 동일하지만 연산자*()가 값 대신 키/값 쌍을 반환한다는 차이점이 있습니다.

QKeyValueIterator도 참조하세요 .

`[alias]` QHash::mapped_type

STL 호환성을 위해 제공되는 T용 Typedef입니다.

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

이렇게 얻은 키와 값은 모두 해시에 있는 키와 값에 대한 참조라는 점에 유의하세요. 특히 값을 변경하면 해시 자체가 수정됩니다.

경고: 반환된 이터레이터/참조는 다음에 해시에 대해 컨스트가 아닌 함수를 호출하거나 해시가 소멸될 때 무효화된 것으로 간주해야 합니다.

이 함수는 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). 범위로 반복되는 요소는 각각 Key 및 T 로 변환 가능한 first 및 second 데이터 멤버(예: std::pair)를 가진 객체이거나, 반복기에 각각 Key 로 변환 가능한 키와 T 로 변환 가능한 값을 반환하는 key() 및 value() 멤버 함수를 가져야 합니다.

`[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 인 경우를 제외하고는 사용할 수 없습니다.

remove()도 참조하세요 .

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

해시의 첫 번째 항목을 가리키는 상수 STL 스타일 이터레이터를 반환합니다.

경고: 반환된 이터레이터/참조는 다음에 해시에서 const가 아닌 함수를 호출하거나 해시가 소멸될 때 무효화된 것으로 간주해야 합니다.

begin() 및 constEnd()도 참조하세요 .

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

해시의 마지막 항목 뒤에 있는 가상의 항목을 가리키는 상수 STL 스타일 이터레이터를 반환합니다.

경고: 반환된 이터레이터/참조는 다음에 해시에서 const가 아닌 함수를 호출하거나 해시가 소멸될 때 무효화된 것으로 간주해야 합니다.

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 ()와 동일하며 해시가 비어 있으면 true를 반환하고, 그렇지 않으면 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 와 연결된 (키, 값) 쌍을 제거하고 해시의 다음 항목으로 반복자를 반환합니다.

이 함수는 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;
}

Warning: 반환된 이터레이터/참조는 다음에 해시에서 컨스트가 아닌 함수를 호출하거나 해시가 소멸될 때 무효화된 것으로 간주해야 합니다.

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 스타일 이터레이터를 반환합니다.

경고: 반환된 이터레이터/참조는 다음에 해시에서 const가 아닌 함수를 호출하거나 해시가 소멸될 때 무효화된 것으로 간주해야 합니다.

keyValueEnd()도 참조하세요 .

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

해시의 마지막 항목 뒤에 있는 가상의 항목을 가리키는 STL 스타일 이터레이터를 반환합니다.

경고: 반환된 이터레이터/참조는 다음에 해시에서 컨스트가 아닌 함수를 호출하거나 해시가 소멸될 때 무효화된 것으로 간주해야 합니다.

keyValueBegin()도 참조하세요 .

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

해시의 마지막 항목 뒤에 있는 가상의 항목을 가리키는 상수 STL 스타일 이터레이터를 반환합니다.

경고: 반환된 이터레이터/참조는 다음에 해시에서 const가 아닌 함수를 호출하거나 해시가 소멸될 때 무효화된 것으로 간주해야 합니다.

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 를 가진 항목을 제거합니다. 키가 해시에 존재하고 항목이 제거된 경우 참을 반환하고 그렇지 않으면 거짓을 반환합니다.

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 의 내부 해시 테이블은 메모리를 너무 많이 낭비하지 않고 좋은 성능을 제공하도록 자동으로 커집니다.

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 을 반환합니다.

두 해시는 동일한 (키, 값) 쌍을 포함하면 동일한 것으로 간주됩니다.

이 함수를 구현하려면 operator==() 을 구현할 값 유형이 필요합니다.

operator==()도 참조하세요 .

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

이동-이 other 인스턴스를 QHash 인스턴스에 할당합니다.

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

이 해시에 other 을 할당하고 이 해시에 대한 참조를 반환합니다.

참고: 이 함수는 std::is_nothrow_destructible<Node>::value 가 true 인 경우를 제외하고는 사용되지 않습니다.

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

other 이 이 해시와 같으면 true 을 반환하고, 그렇지 않으면 false 를 반환합니다.

두 해시는 동일한 (키, 값) 쌍을 포함하는 경우 동일한 것으로 간주됩니다.

이 함수는 operator==() 을 구현하기 위해 값 유형이 필요합니다.

operator!=()도 참조하세요 .

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

수정 가능한 참조로 key 와 연관된 값을 반환합니다.

해시에 key 이 포함된 항목이 없는 경우 이 함수는 key 이 포함된 해시에 기본으로 구성된 값을 삽입하고 이에 대한 참조를 반환합니다.

경고: 반환된 이터레이터/참조는 다음에 해시에서 컨스트가 아닌 함수를 호출하거나 해시가 소멸될 때 무효화된 것으로 간주해야 합니다.

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)

seed 을 사용하여 key 의 해시값을 반환합니다.

참고: Qt 6.5 이전에는 범위가 지정되지 않은 열거형은 기본 정수 유형에 대한 암시적 변환으로 인해 이 함수의 정수 오버로드에 의존했습니다. 범위가 지정된 열거형의 경우 오버로드를 직접 구현해야 했습니다. 이것은 여전히 이전 Qt 버전과의 호환성을 유지하기 위한 하위 호환성 수정입니다.

이 함수는 Qt 6.5에 도입되었습니다.

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

seed 을 사용하여 key 에 대한 해시값을 반환합니다.

`[constexpr noexcept]` size_t qHash(ushort 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]` size_t qHash(QLatin1StringView key, size_t seed = 0)

seed 을 사용하여 key 에 대한 해시값을 반환합니다.

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

seed 을 사용하여 key 에 대한 해시값을 반환합니다.

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

seed 을 사용하여 key 의 해시값을 반환합니다.

이 함수는 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)

seed 을 사용하여 key 의 해시값을 반환합니다.

이 함수는 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)

seed 을 사용하여 key 에 대한 해시값을 반환합니다.

`[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 에 대한 해시값을 반환합니다.

qHash()는 Key 및 T 유형을 지원해야 합니다.

참고: 이 함수는 noexcept(qHash(std::declval<Key&>())) && noexcept(qHash(std::declval<T&>())) 가 true 인 경우를 제외하고는 사용할 수 없습니다.

`[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]` 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 &key, size_t seed = 0)

seed 을 사용하여 key 에 대한 해시값을 반환합니다.

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

seed 을 사용하여 key 에 대한 해시값을 반환합니다.

`[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 에 대한 해시값을 반환합니다.

qHash()는 T1 및 T2 유형을 지원해야 합니다.

참고: 이 함수는 QHashPrivate::noexceptPairHash<T1, T2>() 가 true 인 경우를 제외하고는 사용할 수 없습니다.

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

seed 을 사용하여 key 에 대한 해시값을 반환합니다.

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

seed 을 사용하여 key 에 대한 해시값을 반환합니다.

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

seed 을 사용하여 key 에 대한 해시값을 반환합니다.

참고: 이 함수는 기본 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)

seed 을 사용하여 key 에 대한 해시값을 반환합니다.

`[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 에 대한 해시값을 반환합니다.

`[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()를 대신 사용해야 합니다.

Qt에서 제공하는 qHash() 오버로드와 같이 qHashBits() 구현은 언제든지 변경될 수 있다는 점을 다시 한 번 강조합니다. qHashBits()가 다른 Qt 버전에서 (동일한 입력에 대해) 동일한 결과를 제공한다는 사실에 의존해서는 안 됩니다.

qHashRange() 및 qHashRangeCommutative()도 참조하십시오 .

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

seed 을 사용하여 각 요소에 qHash()을 연속적으로 적용하고 해시값을 하나의 해시값으로 결합하여 args 에 대한 해시값을 반환합니다.

인수의 순서는 중요하다는 점에 유의하세요. 순서가 중요하지 않은 경우 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 인 경우를 제외하고는 사용되지 않습니다.

qHashMultiCommutative 및 qHashRange 을참조하십시오 .

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

seed 을 사용하여 각 요소에 qHash()을 연속적으로 적용하고 해시값을 하나의 해시값으로 결합하여 args 에 대한 해시값을 반환합니다.

인수의 순서는 중요하지 않습니다. 순서가 중요한 경우에는 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()를 연속적으로 적용하고 해시값을 하나의 해시값으로 결합하여 계산을 시드하는 방식으로 범위 [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);
}

Qt에서 제공하는 qHash() 오버로드와 마찬가지로 qHashRange() 구현은 언제든지 변경될 수 있다는 점을 다시 한 번 강조합니다. 요소 유형에 대한 qHash()가 다른 Qt 버전에서 동일한 결과를 제공하더라도 qHashRange()가 (동일한 입력에 대해) 동일한 결과를 제공한다는 사실에 의존해서는 안 됩니다.

참고: 이 함수는 noexcept(qHash(*first)) 가 true 일 때를 제외하고는 작동하지 않습니다.

qHashBits() 및 qHashRangeCommutative()도 참조하십시오 .

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

이 함수의 반환 값은 범위 내 요소의 순서에 의존하지 않습니다. 즉

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

Qt에서 제공하는 qHash() 오버로드와 마찬가지로 qHashRangeCommutative() 구현은 언제든지 변경될 수 있다는 점을 다시 한 번 강조합니다. 요소 유형에 대한 qHash()가 다른 Qt 버전에서 동일한 결과를 제공하더라도 qHashRangeCommutative()가 (동일한 입력에 대해) 동일한 결과를 제공한다는 사실에 의존해서는 안 됩니다.

참고: 이 함수는 noexcept(qHash(*first)) 가 true 일 때를 제외하고는 작동하지 않습니다.

qHashBits() 및 qHashRange()도 참조하십시오 .

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

out 을 스트리밍하기 위해 hash 해시를 씁니다.

이 함수는 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)