Sur cette page

QSet Class

template <typename T> class QSet

La classe QSet est une classe modèle qui fournit un ensemble basé sur une table de hachage. Plus d'informations...

En-tête : #include <QSet>
CMake : find_package(Qt6 REQUIRED COMPONENTS Core)
target_link_libraries(mytarget PRIVATE Qt6::Core)
qmake : QT += core

Cette classe est comparable à l'égalité.

Remarque : toutes les fonctions de cette classe sont réentrantes.

Types publics

Fonctions publiques

QSet()
QSet(std::initializer_list<T> list)
QSet(InputIterator first, InputIterator last)
QSet<T>::const_iterator begin() const
QSet<T>::iterator begin()
qsizetype capacity() const
QSet<T>::const_iterator cbegin() const
QSet<T>::const_iterator cend() const
void clear()
QSet<T>::const_iterator constBegin() const
QSet<T>::const_iterator constEnd() const
QSet<T>::const_iterator constFind(const T &value) const
bool contains(const QSet<T> &other) const
bool contains(const T &value) const
qsizetype count() const
bool empty() const
QSet<T>::const_iterator end() const
QSet<T>::iterator end()
QSet<T>::iterator erase(QSet<T>::const_iterator pos)
QSet<T>::const_iterator find(const T &value) const
QSet<T>::iterator find(const T &value)
QSet<T>::iterator insert(const T &value)
(since 6.1) QSet<T>::iterator insert(QSet<T>::const_iterator it, const T &value)
QSet<T> &intersect(const QSet<T> &other)
bool intersects(const QSet<T> &other) const
bool isEmpty() const
bool remove(const T &value)
(since 6.1) qsizetype removeIf(Pred pred)
void reserve(qsizetype size)
qsizetype size() const
void squeeze()
QSet<T> &subtract(const QSet<T> &other)
void swap(QSet<T> &other)
QSet<T> &unite(QSet<T> &&other)
QSet<T> &unite(const QSet<T> &other)
QList<T> values() const
QSet<T> &operator&=(const QSet<T> &other)
QSet<T> &operator&=(const T &value)
QSet<T> &operator+=(QSet<T> &&other)
QSet<T> &operator+=(const QSet<T> &other)
QSet<T> &operator+=(const T &value)
QSet<T> &operator-=(const QSet<T> &other)
QSet<T> &operator-=(const T &value)
QSet<T> &operator<<(const T &value)
QSet<T> &operator|=(QSet<T> &&other)
QSet<T> &operator|=(const QSet<T> &other)
QSet<T> &operator|=(const T &value)
(since 6.1) qsizetype erase_if(QSet<T> &set, Predicate pred)
bool operator!=(const QSet<T> &lhs, const QSet<T> &rhs)
QSet<T> operator&(QSet<T> &&lhs, const QSet<T> &rhs)
QSet<T> operator&(const QSet<T> &lhs, const QSet<T> &rhs)
QSet<T> operator+(QSet<T> &&lhs, QSet<T> &&rhs)
QSet<T> operator+(QSet<T> &&lhs, const QSet<T> &rhs)
QSet<T> operator+(const QSet<T> &lhs, QSet<T> &&rhs)
QSet<T> operator+(const QSet<T> &lhs, const QSet<T> &rhs)
QSet<T> operator-(QSet<T> &&lhs, const QSet<T> &rhs)
QSet<T> operator-(const QSet<T> &lhs, const QSet<T> &rhs)
QDataStream &operator<<(QDataStream &out, const QSet<T> &set)
bool operator==(const QSet<T> &lhs, const QSet<T> &rhs)
QDataStream &operator>>(QDataStream &in, QSet<T> &set)
QSet<T> operator|(QSet<T> &&lhs, QSet<T> &&rhs)
QSet<T> operator|(QSet<T> &&lhs, const QSet<T> &rhs)
QSet<T> operator|(const QSet<T> &lhs, QSet<T> &&rhs)
QSet<T> operator|(const QSet<T> &lhs, const QSet<T> &rhs)

Description détaillée

QSet<T> est l'une des classes de conteneurs génériques de Qt. Elle stocke des valeurs dans un ordre non spécifié et permet une consultation très rapide des valeurs. En interne, QSet<T> est implémenté en tant que QHash.

Voici un exemple de QSet avec QString valeurs :

Pour insérer une valeur dans l'ensemble, utilisez insert() :

set.insert("one");
set.insert("three");
set.insert("seven");

Une autre façon d'insérer des éléments dans l'ensemble est d'utiliser operator<<() :

set << "twelve" << "fifteen" << "nineteen";

Pour tester si un élément appartient ou non à l'ensemble, utilisez contains() :

if (!set.contains("ninety-nine"))
    {/*...*/}

Si vous souhaitez parcourir toutes les valeurs stockées dans un QSet, vous pouvez utiliser un itérateur. QSet prend en charge les itérateurs de style Java (QSetIterator et QMutableSetIterator) et les itérateurs de style STL (QSet::iterator et QSet::const_iterator). Voici comment parcourir un QSet<QWidget *> à l'aide d'un itérateur de style Java :

QSetIterator<QWidget*> i(set) ;while (i.hasNext()) { QWidget *w = i.next() ;    qDebug() << w;
}

Voici le même code, mais en utilisant un itérateur de type STL :

for(auto i = set.cbegin(), end = set.cend() ; i != end ; ++i)    qDebug() << *i;

QSet n'étant pas ordonné, la séquence d'un itérateur ne peut pas être considérée comme prévisible. Si l'ordre par clé est nécessaire, utilisez un QMap.

Pour naviguer dans un QSet, vous pouvez également utiliser des itérateurs basés sur des plages :

QSet<QString> set ;//...for(const auto &value: set)    qDebug() << value;

Les éléments peuvent être retirés de l'ensemble à l'aide de la fonction remove(). Il existe également une fonction clear() qui supprime tous les éléments.

Le type de données de la valeur de QSet doit être un type de données assignable. Vous ne pouvez pas, par exemple, stocker un QWidget en tant que valeur, mais plutôt un QWidget *. En outre, le type doit fournir operator==(), et il doit également exister une fonction globale qHash() qui renvoie une valeur de hachage pour un argument du type de la clé. Voir la documentation QHash pour une liste des types pris en charge par qHash().

En interne, QSet utilise une table de hachage pour effectuer des recherches. La table de hachage croît et décroît automatiquement pour permettre des recherches rapides sans gaspiller de mémoire. Vous pouvez toujours contrôler la taille de la table de hachage en appelant reserve(), si vous savez déjà approximativement combien d'éléments le QSet contiendra, mais ce n'est pas nécessaire pour obtenir de bonnes performances. Vous pouvez également appeler capacity() pour récupérer la taille de la table de hachage.

Voir aussi QSetIterator, QMutableSetIterator, QHash, et QMap.

Documentation sur les types de membres

QSet::ConstIterator

Qt-style synonyme de QSet::const_iterator.

QSet::Iterator

Qt-style synonyme de QSet::iterator.

QSet::const_pointer

Typedef pour const T *. Fourni pour la compatibilité STL.

QSet::const_reference

Typedef pour const T &. Fourni pour la compatibilité STL.

QSet::difference_type

Typedef pour const ptrdiff_t. Fourni pour la compatibilité STL.

QSet::key_type

Typedef pour T. Fourni pour la compatibilité STL.

QSet::pointer

Typedef pour T *. Fourni pour la compatibilité STL.

QSet::reference

Typedef pour T &. Fourni pour la compatibilité STL.

QSet::size_type

Typedef pour int. Fourni pour la compatibilité STL.

QSet::value_type

Typedef pour T. Fourni pour la compatibilité STL.

Documentation sur les fonctions membres

[noexcept] QSet::QSet()

Construit un ensemble vide.

Voir aussi clear().

QSet::QSet(std::initializer_list<T> list)

Construit un ensemble avec une copie de chacun des éléments de la liste d'initialisation list.

template <typename InputIterator, QtPrivate::IfIsInputIterator<InputIterator> = true> QSet::QSet(InputIterator first, InputIterator last)

Construit un ensemble dont le contenu se trouve dans l'intervalle de l'itérateur [first, last).

Le type de valeur de InputIterator doit être convertible en T.

Remarque : si l'intervalle [first, last) contient des éléments en double, le premier est conservé.

[noexcept] QSet<T>::const_iterator QSet::begin() const

Renvoie un itérateur de style STL constant positionné sur le premier élément de l'ensemble.

Voir aussi constBegin() et end().

QSet<T>::iterator QSet::begin()

Renvoie un itérateur non-const de style STL positionné sur le premier élément de l'ensemble.

Il s'agit d'une fonction surchargée.

qsizetype QSet::capacity() const

Renvoie le nombre de godets dans la table de hachage interne de l'ensemble.

Le seul but de cette fonction est de fournir un moyen d'affiner l'utilisation de la mémoire de QSet. En général, vous n'aurez que rarement besoin d'appeler cette fonction. Si vous souhaitez connaître le nombre d'éléments contenus dans l'ensemble, appelez size().

Voir aussi reserve() et squeeze().

[noexcept] QSet<T>::const_iterator QSet::cbegin() const

Renvoie un itérateur de style STL constant positionné sur le premier élément de l'ensemble.

Voir aussi begin() et cend().

[noexcept] QSet<T>::const_iterator QSet::cend() const

Renvoie un itérateur constant de style STL pointant vers l'élément imaginaire situé après le dernier élément de l'ensemble.

Voir aussi cbegin() et end().

void QSet::clear()

Supprime tous les éléments de l'ensemble.

Voir également remove().

[noexcept] QSet<T>::const_iterator QSet::constBegin() const

Renvoie un itérateur de style STL constant positionné sur le premier élément de l'ensemble.

Voir aussi begin() et constEnd().

[noexcept] QSet<T>::const_iterator QSet::constEnd() const

Renvoie un itérateur constant de style STL pointant vers l'élément imaginaire situé après le dernier élément de l'ensemble.

Voir aussi constBegin() et end().

QSet<T>::const_iterator QSet::constFind(const T &value) const

Renvoie un itérateur constant positionné sur l'élément value de l'ensemble. Si l'ensemble ne contient pas d'élément value, la fonction renvoie constEnd().

Voir aussi find() et contains().

bool QSet::contains(const QSet<T> &other) const

Renvoie true si l'ensemble contient tous les éléments de l'ensemble other; sinon, renvoie false.

Voir aussi insert(), remove() et find().

bool QSet::contains(const T &value) const

Renvoie true si l'ensemble contient l'élément value; sinon, renvoie false.

Voir aussi insert(), remove() et find().

qsizetype QSet::count() const

Identique à size().

bool QSet::empty() const

Renvoie true si l'ensemble est vide. Cette fonction est fournie pour la compatibilité STL. Elle est équivalente à isEmpty().

[noexcept] QSet<T>::const_iterator QSet::end() const

Renvoie un itérateur de style STL constant positionné sur l'élément imaginaire situé après le dernier élément de l'ensemble.

Voir aussi constEnd() et begin().

QSet<T>::iterator QSet::end()

Renvoie un itérateur non-const de style STL pointant vers l'élément imaginaire situé après le dernier élément de l'ensemble.

Il s'agit d'une fonction surchargée.

QSet<T>::iterator QSet::erase(QSet<T>::const_iterator pos)

Retire de l'ensemble l'élément situé à la position de l'itérateur pos et renvoie un itérateur positionné sur l'élément suivant de l'ensemble.

Contrairement à remove(), cette fonction n'oblige jamais QSet à remanier sa structure de données interne. Cela signifie qu'elle peut être appelée en toute sécurité pendant l'itération et qu'elle n'affectera pas l'ordre des éléments dans l'ensemble.

Remarque : l'itérateur pos doit être valide et déréférençable. L'appel de cette méthode sur tout autre itérateur, y compris son propre end(), entraîne un comportement indéfini. En particulier, même l'itérateur begin() d'un ensemble vide ne peut pas être déréférencé.

Voir également remove() et find().

QSet<T>::const_iterator QSet::find(const T &value) const

Renvoie un itérateur constant positionné sur l'élément value de l'ensemble. Si l'ensemble ne contient pas d'élément value, la fonction renvoie constEnd().

Voir aussi constFind() et contains().

QSet<T>::iterator QSet::find(const T &value)

Renvoie un itérateur non-const positionné sur l'élément value de l'ensemble. Si l'ensemble ne contient pas d'élément value, la fonction renvoie end().

Il s'agit d'une fonction surchargée.

QSet<T>::iterator QSet::insert(const T &value)

Insère l'élément value dans l'ensemble, si value n'est pas déjà dans l'ensemble, et renvoie un itérateur pointant sur l'élément inséré.

Voir aussi operator<<(), remove() et contains().

[since 6.1] QSet<T>::iterator QSet::insert(QSet<T>::const_iterator it, const T &value)

Insère l'élément value dans l'ensemble, si value n'est pas déjà dans l'ensemble, et renvoie un itérateur pointant sur l'élément inséré.

L'itérateur it est ignoré.

Cette fonction est fournie pour des raisons de compatibilité avec la STL.

Il s'agit d'une fonction surchargée.

Cette fonction a été introduite dans Qt 6.1.

Voir aussi operator<<(), remove(), et contains().

QSet<T> &QSet::intersect(const QSet<T> &other)

Supprime tous les éléments de cet ensemble qui ne sont pas contenus dans l'ensemble other. Une référence à cet ensemble est renvoyée.

Voir aussi intersects(), operator&=(), unite() et subtract().

bool QSet::intersects(const QSet<T> &other) const

Renvoie true si cet ensemble a au moins un élément en commun avec other.

Voir aussi contains() et intersect().

bool QSet::isEmpty() const

Renvoie true si l'ensemble ne contient aucun élément, sinon renvoie false.

Voir aussi size().

bool QSet::remove(const T &value)

Supprime de l'ensemble toute occurrence de l'élément value. Retourne vrai si un élément a été effectivement supprimé ; sinon, retourne false.

Voir également contains() et insert().

[since 6.1] template <typename Pred> qsizetype QSet::removeIf(Pred pred)

Supprime de cet ensemble tous les éléments pour lesquels le prédicat pred renvoie true. Renvoie le nombre d'éléments supprimés, le cas échéant.

Cette fonction a été introduite dans Qt 6.1.

void QSet::reserve(qsizetype size)

Assure que la table de hachage interne de l'ensemble est composée d'au moins size buckets.

Cette fonction est utile pour le code qui a besoin de construire un ensemble énorme et qui veut éviter les réallocations répétées. Par exemple :

QSet<QString> set;
set.reserve(20000);
for (int i = 0; i < 20000; ++i)
    set.insert(values[i]);

Idéalement, size devrait être légèrement supérieur au nombre maximal d'éléments attendus dans l'ensemble. size n'a pas besoin d'être premier, car QSet utilisera de toute façon un nombre premier en interne. Si size est sous-estimé, le pire qui puisse arriver est que QSet soit un peu plus lent.

En général, vous n'aurez que rarement besoin d'appeler cette fonction. QSet En effet, la table de hachage interne du programme se réduit ou s'agrandit automatiquement afin d'assurer de bonnes performances sans gaspiller trop de mémoire.

Voir aussi squeeze() et capacity().

qsizetype QSet::size() const

Renvoie le nombre d'éléments de l'ensemble.

Voir aussi isEmpty() et count().

void QSet::squeeze()

Réduit la taille de la table de hachage interne de l'ensemble pour économiser de la mémoire.

Le seul but de cette fonction est de fournir un moyen d'affiner l'utilisation de la mémoire de QSet. En général, vous n'aurez que rarement besoin d'appeler cette fonction.

Voir aussi reserve() et capacity().

QSet<T> &QSet::subtract(const QSet<T> &other)

Supprime tous les éléments de cet ensemble qui sont contenus dans l'ensemble other. Renvoie une référence à cet ensemble.

Voir aussi operator-=(), unite() et intersect().

[noexcept] void QSet::swap(QSet<T> &other)

Remplace cet ensemble par other. Cette opération est très rapide et n'échoue jamais.

QSet<T> &QSet::unite(const QSet<T> &other)

QSet<T> &QSet::unite(QSet<T> &&other)

Chaque élément de l'ensemble other qui n'est pas déjà dans cet ensemble est inséré dans cet ensemble. Une référence à cet ensemble est renvoyée.

Voir aussi operator|=(), intersect() et subtract().

QList<T> QSet::values() const

Renvoie un nouveau QList contenant les éléments de l'ensemble. L'ordre des éléments dans QList n'est pas défini.

Remarque : depuis Qt 5.14, des constructeurs de plages sont disponibles pour les classes de conteneurs génériques de Qt et doivent être utilisés à la place de cette méthode.

Cette fonction crée une nouvelle liste, en temps linéaire. L'utilisation du temps et de la mémoire que cela implique peut être évitée en itérant de constBegin() à constEnd().

QSet<T> &QSet::operator&=(const QSet<T> &other)

Identique à intersect(other).

Voir aussi operator&(), operator|=() et operator-=().

QSet<T> &QSet::operator&=(const T &value)

Identique à intersect(other)si nous considérons other comme un ensemble contenant le singleton value.

Il s'agit d'une fonction surchargée.

QSet<T> &QSet::operator-=(const QSet<T> &other)

Identique à subtract(other).

Voir aussi operator-(), operator|=() et operator&=().

QSet<T> &QSet::operator-=(const T &value)

Supprime l'occurrence de l'élément value de l'ensemble, si elle est trouvée, et renvoie une référence à l'ensemble. Si l'élément value n'est pas contenu dans l'ensemble, rien n'est supprimé.

Voir aussi remove().

QSet<T> &QSet::operator<<(const T &value)

QSet<T> &QSet::operator+=(const T &value)

QSet<T> &QSet::operator|=(const T &value)

Insère un nouvel élément value et renvoie une référence à l'ensemble. Si value existe déjà dans l'ensemble, l'ensemble reste inchangé.

Voir aussi insert().

QSet<T> &QSet::operator|=(const QSet<T> &other)

QSet<T> &QSet::operator|=(QSet<T> &&other)

QSet<T> &QSet::operator+=(const QSet<T> &other)

QSet<T> &QSet::operator+=(QSet<T> &&other)

Identique à unite(other).

Voir aussi operator|(), operator&=(), et operator-=().

Non-membres apparentés

[since 6.1] template <typename T, typename Predicate> qsizetype erase_if(QSet<T> &set, Predicate pred)

Supprime de l'ensemble set tous les éléments pour lesquels le prédicat pred renvoie un résultat vrai. Renvoie le nombre d'éléments supprimés, le cas échéant.

Cette fonction a été introduite dans Qt 6.1.

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

Renvoie true si l'ensemble lhs n'est pas égal à l'ensemble rhs; sinon, renvoie false.

Deux ensembles sont considérés comme égaux s'ils contiennent les mêmes éléments.

Cette fonction nécessite le type de valeur pour implémenter operator==().

Voir également operator==().

QSet<T> operator&(const QSet<T> &lhs, const QSet<T> &rhs)

QSet<T> operator&(QSet<T> &&lhs, const QSet<T> &rhs)

Renvoie un nouveau QSet qui est l'intersection des ensembles lhs et rhs.

Voir aussi intersect(), operator&=(), operator|(), et operator-().

QSet<T> operator-(const QSet<T> &lhs, const QSet<T> &rhs)

QSet<T> operator-(QSet<T> &&lhs, const QSet<T> &rhs)

Renvoie un nouveau QSet qui est la différence des ensembles lhs et rhs.

Voir aussi subtract(), operator-=(), operator|(), et operator&().

template <typename T> QDataStream &operator<<(QDataStream &out, const QSet<T> &set)

Écrit la valeur set dans le flux out.

Cette fonction nécessite que le type de valeur soit implémenté operator<<().

Voir aussi Format des opérateurs QDataStream.

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

Renvoie true si l'ensemble lhs est égal à l'ensemble rhs; sinon, renvoie false.

Deux ensembles sont considérés comme égaux s'ils contiennent les mêmes éléments.

Cette fonction nécessite le type de valeur pour implémenter operator==().

Voir également operator!=().

template <typename T> QDataStream &operator>>(QDataStream &in, QSet<T> &set)

Lit un ensemble du flux in dans set.

Cette fonction nécessite que le type de valeur soit implémenté operator>>().

Voir aussi Format des opérateurs QDataStream.

QSet<T> operator|(const QSet<T> &lhs, const QSet<T> &rhs)

QSet<T> operator|(const QSet<T> &lhs, QSet<T> &&rhs)

QSet<T> operator|(QSet<T> &&lhs, const QSet<T> &rhs)

QSet<T> operator|(QSet<T> &&lhs, QSet<T> &&rhs)

QSet<T> operator+(const QSet<T> &lhs, const QSet<T> &rhs)

QSet<T> operator+(const QSet<T> &lhs, QSet<T> &&rhs)

QSet<T> operator+(QSet<T> &&lhs, const QSet<T> &rhs)

QSet<T> operator+(QSet<T> &&lhs, QSet<T> &&rhs)

Renvoie un nouveau QSet qui est l'union des ensembles lhs et rhs.

Voir aussi unite(), operator|=(), operator&(), et operator-().

© 2026 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.