QMultiHash Class

Documentation des fonctions membres

[noexcept default] QMultiHash::QMultiHash()

Crée un hachage vide.

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

Crée une copie de ` other ` (qui peut être un ` QHash ` ou un `QMultiHash`).

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

Crée un « multi-hash » à partir d'une copie de chacun des éléments de la liste d'initialisation list.

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

Construit un multi-hash à partir d'une copie de chacun des éléments de la plage de l'itérateur [begin, end). Soit les éléments parcourus par la plage doivent être des objets dotés de membres de données first et second (comme std::pair), convertibles respectivement en Key et en T; soit les itérateurs doivent disposer de fonctions membres key() et value(), renvoyant respectivement une clé convertible en Key et une valeur convertible en T.

Renvoie un objet « range » qui permet de parcourir ce hachage sous forme de paires clé/valeur. Par exemple, cet objet « range » peut être utilisé dans une boucle « for » basée sur une plage, en combinaison avec une déclaration de liaison structurée :

QMultiHash<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
}

Notez que la clé et la valeur obtenues de cette manière sont toutes deux des références à celles contenues dans le hachage. Plus précisément, la modification de la valeur entraînera la modification du hachage lui-même.

Ces fonctions ont été introduites dans Qt 6.4.

Voir également QKeyValueIterator.

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

Renvoie un itérateur de type STL pointant vers le premier élément du hachage.

Voir également constBegin() et end().

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

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

Renvoie un itérateur de type STL constant pointant vers le premier élément du hachage.

Voir également begin() et cend().

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

Renvoie un itérateur de type STL (const) pointant vers l'élément imaginaire situé après le dernier élément du hachage.

Voir également cbegin() et end().

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

Supprime tous les éléments du hachage et libère toute la mémoire qu'il occupe.

Voir aussi ` remove()`.

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

Renvoie un itérateur constant de type STL pointant vers le premier élément du hachage.

Voir également begin() et constEnd().

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

Renvoie un itérateur de type STL (const) pointant vers l'élément imaginaire situé après le dernier élément du hachage.

Voir également constBegin() et end().

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

Renvoie un itérateur pointant vers l'élément du hachage dont la clé est « key » et la valeur est « value ».

Si le hachage ne contient pas d'élément de ce type, la fonction renvoie ` constEnd()`.

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

Renvoie un itérateur de type STL constant pointant vers la première entrée du hachage.

Voir également ` keyValueBegin()`.

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

Renvoie un itérateur de type STL (const) pointant vers l'entrée imaginaire située après la dernière entrée du hachage.

Voir aussi ` constKeyValueBegin()`.

[noexcept] bool QMultiHash::contains(const Key &key, const T &value) const

Renvoie « true » si le hachage contient un élément dont la clé est « key » et la valeur « value » ; sinon, renvoie « false ».

Voir également count().

[noexcept] qsizetype QMultiHash::count(const Key &key, const T &value) const

Renvoie le nombre d'éléments répondant aux conditions key et value.

Voir aussi contains().

Insère un nouvel élément dans le conteneur. Ce nouvel élément est créé sur place en utilisant args comme arguments de construction.

S’il existe déjà un élément portant la même clé dans le hachage, cette fonction se contente d’en créer un nouveau. (Ce comportement diffère de celui de la fonction ` replace()`, qui écrase la valeur d’un élément existant.)

Renvoie un itérateur pointant vers le nouvel élément.

Voir aussi insert.

Insère un nouvel élément dans le conteneur. Ce nouvel élément est construit sur place à l'aide de ` args ` comme arguments de construction.

S'il existe déjà un élément portant la même clé dans le hachage, la valeur de cet élément est remplacée par une valeur construite à partir de ` args`.

Renvoie un itérateur pointant vers le nouvel élément.

Voir également ` replace ` et ` emplace`.

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

Renvoie un itérateur de type STL pointant vers l'élément imaginaire situé après le dernier élément du hachage.

Voir également begin() et constEnd().

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

std::pair<QMultiHash<Key, T>::iterator, QMultiHash<Key, T>::iterator> QMultiHash::equal_range(const Key &key)

Renvoie une paire d’itérateurs délimitant l’intervalle de valeurs [first, second), qui sont stockées sous key. Si l’intervalle est vide, les deux itérateurs seront égaux à end().

[noexcept] std::pair<QMultiHash<Key, T>::const_iterator, QMultiHash<Key, T>::const_iterator> QMultiHash::equal_range(const Key &key) const

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

Supprime de la table de hachage la paire (clé, valeur) associée à l'itérateur pos, puis renvoie un itérateur vers l'élément suivant de la table.

Cette fonction ne provoque jamais la réorganisation de la structure de données interne d'QMultiHash. Cela signifie qu'elle peut être appelée en toute sécurité pendant une itération et qu'elle n'affectera pas l'ordre des éléments dans le hachage. Par exemple :

QMultiHash<QObject *, int> objectHash;
//...
QMultiHash<QObject *, int>::iterator i = objectHash.find(obj);
while (i != objectHash.end() && i.key() == obj) {
    if (i.value() == 0) {
        i = objectHash.erase(i);
    } else {
        ++i;
    }
}

Voir également remove(), take() et find().

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

Renvoie un itérateur pointant vers l'élément dont les clés sont « key » et « value ». Si le hachage ne contient aucun élément correspondant, la fonction renvoie « end() ».

Si le hachage contient plusieurs éléments ayant les key et value, l’itérateur renvoyé pointe vers l’élément inséré le plus récemment.

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

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

Insère un nouvel élément avec la clé « key » et la valeur « value ».

S'il existe déjà un élément portant la même clé dans le hachage, cette fonction en créera simplement un nouveau. (Ce comportement diffère de celui de la fonction ` replace()`, qui écrase la valeur d'un élément existant.)

QMultiHash autorise les clés en double. L'insertion d'une clé existante ajoute une nouvelle entrée au lieu de la remplacer. L'ordre des éléments dans QMultHash n'est pas garanti.

Renvoie un itérateur pointant vers le nouvel élément.

Voir également ` replace()`.

Ces fonctions ont été introduites dans Qt 6.11.

Renvoie la première clé associée à value. Si le hachage ne contient aucun élément associé à value, renvoie defaultKey, ou une clé construite par défaut si ce paramètre n'a pas été fourni.

Cette fonction peut être lente (temps linéaire), car la structure de données interne de ` QMultiHash` est optimisée pour une recherche rapide par clé, et non par valeur.

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

Renvoie un itérateur de type STL constant pointant vers la première clé du hachage.

Voir aussi ` keyEnd()`.

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

Renvoie un itérateur de type STL constant pointant vers l'élément imaginaire situé après la dernière clé du hachage.

Voir aussi ` keyBegin()`.

[noexcept] QMultiHash<Key, T>::key_value_iterator QMultiHash::keyValueBegin()

Renvoie un itérateur de type STL pointant vers la première entrée du hachage.

Voir aussi ` keyValueEnd()`.

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

Renvoie un itérateur const de type STL pointant vers la première entrée du hachage.

Voir également ` keyValueEnd()`.

[noexcept] QMultiHash<Key, T>::key_value_iterator QMultiHash::keyValueEnd()

Renvoie un itérateur de type STL pointant vers l'entrée imaginaire située après la dernière entrée du hachage.

Voir également ` keyValueBegin()`.

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

Renvoie un itérateur de type STL (const) pointant vers l’entrée imaginaire située après la dernière entrée du hachage.

Voir aussi ` keyValueBegin()`.

QList<Key> QMultiHash::keys() const

Renvoie une liste contenant toutes les clés du hachage, dans un ordre aléatoire. Les clés qui apparaissent plusieurs fois dans le hachage apparaissent également plusieurs fois dans la liste.

L'ordre est garanti d'être le même que celui utilisé par la fonction values().

Cette fonction crée une nouvelle liste, en temps linéaire. La consommation de temps et de mémoire que cela implique peut être évitée en itérant de ` keyBegin()` à ` keyEnd()`.

Voir également values() et key().

qsizetype QMultiHash::remove(const Key &key)

Supprime du hachage tous les éléments dont l'key correspond. Renvoie le nombre d'éléments supprimés.

Voir aussi remove(const Key &key, const T &value).

qsizetype QMultiHash::remove(const Key &key, const T &value)

Supprime du hachage tous les éléments dont la clé est « key » et la valeur est « value ». Renvoie le nombre d’éléments supprimés.

Voir aussi remove().

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

Supprime du multi-hash tous les éléments pour lesquels le prédicat pred renvoie « vrai ».

La fonction prend en charge les prédicats qui acceptent soit un argument de type ` QMultiHash<Key, T>::iterator`, soit un argument de type ` std::pair<const Key &, T &>`.

Renvoie le nombre d’éléments supprimés, le cas échéant.

Cette fonction a été introduite dans Qt 6.1.

Voir également clear() et take().

QMultiHash<Key, T>::iterator QMultiHash::replace(const Key &key, const T &value)

Insère un nouvel élément avec l'key et la valeur value.

S'il existe déjà un élément portant l'key, la valeur de cet élément est remplacée par value.

S'il existe plusieurs éléments portant l'key, la valeur de l'élément inséré le plus récemment est remplacée par value.

Renvoie un itérateur pointant vers l’élément nouveau ou mis à jour.

Voir aussi insert().

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

Permet d'échanger ce multi-hash contre other. Cette opération est très rapide et ne rencontre jamais d'échec.

T QMultiHash::take(const Key &key)

Supprime de l'hachage l'élément portant l'key et renvoie la valeur qui lui est associée.

Si l'élément n'existe pas dans le hachage, la fonction renvoie simplement une valeur construite par défaut. S'il existe plusieurs éléments correspondant à « key » dans le hachage, seul celui qui a été inséré le plus récemment est supprimé.

Si vous n'utilisez pas la valeur renvoyée, la fonction remove() est plus efficace.

Voir également ` remove()`.

QList<Key> QMultiHash::uniqueKeys() const

Renvoie une liste contenant toutes les clés de la table. Les clés qui apparaissent plusieurs fois dans la table n'apparaissent qu'une seule fois dans la liste renvoyée.

Voir également keys() et values().

[since 6.0] QMultiHash<Key, T> &QMultiHash::unite(const QHash<Key, T> &other)

Insère tous les éléments du hachage ` other ` dans ce hachage et renvoie une référence à ce hachage.

Cette fonction a été introduite dans Qt 6.0.

Voir aussi insert().

QMultiHash<Key, T> &QMultiHash::unite(const QMultiHash<Key, T> &other)

Insère tous les éléments du hachage other dans ce hachage et renvoie une référence à ce hachage.

Voir aussi insert().

Renvoie la valeur associée à l'key.

Si le hachage ne contient aucun élément portant l'key, la fonction renvoie ` defaultValue`, ou une valeur construite par défaut si ce paramètre n'a pas été fourni.

S'il existe plusieurs éléments correspondant à l'key dans le hachage, la valeur de celui qui a été inséré le plus récemment est renvoyée.

QList<T> QMultiHash::values() const

Renvoie une liste contenant toutes les valeurs du hachage, dans un ordre aléatoire. Si une clé est associée à plusieurs valeurs, toutes ces valeurs figureront dans la liste, et pas seulement celle qui a été insérée en dernier.

L'ordre est garanti d'être le même que celui utilisé par la fonction ` keys()`.

Cette fonction crée une nouvelle liste, en temps linéaire. La consommation de temps et de mémoire que cela implique peut être évitée en itérant de ` keyValueBegin()` à ` keyValueEnd()`.

Voir également keys() et value().

QList<T> QMultiHash::values(const Key &key) const

Renvoie une liste de toutes les valeurs associées à l'key, de la plus récente à la plus ancienne.

Voir également ` count()` et ` insert()`.

QMultiHash<Key, T> QMultiHash::operator+(const QMultiHash<Key, T> &other) const

Renvoie un hachage contenant tous les éléments de ce hachage ainsi que tous ceux de other. Si une clé est commune aux deux hachages, le hachage résultant contiendra cette clé plusieurs fois.

Voir aussi operator+=().

QMultiHash<Key, T> &QMultiHash::operator+=(const QMultiHash<Key, T> &other)

Insère tous les éléments du hachage other dans ce hachage et renvoie une référence à ce dernier.

Voir aussi unite() et insert().

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

Renvoie la valeur associée à l'key sous forme de référence modifiable.

Si le hachage ne contient aucun élément portant l'key, la fonction insère dans le hachage une valeur construite par défaut portant l'key, puis renvoie une référence à celle-ci.

Si le hachage contient plusieurs éléments portant l'key, cette fonction renvoie une référence à la valeur la plus récemment insérée.

Voir également insert() et value().