<QtAlgorithms> - Generic Algorithms
L'en-tête <QtAlgorithms> inclut les algorithmes génériques basés sur des modèles. En savoir plus…
| Header: | #include <QtAlgorithms> |
Fonctions
| uint | qCountLeadingZeroBits(quint16 v) |
| uint | qCountLeadingZeroBits(quint32 v) |
| uint | qCountLeadingZeroBits(quint64 v) |
| uint | qCountLeadingZeroBits(quint8 v) |
| uint | qCountTrailingZeroBits(quint8 v) |
| uint | qCountTrailingZeroBits(quint16 v) |
| uint | qCountTrailingZeroBits(quint32 v) |
| uint | qCountTrailingZeroBits(quint64 v) |
| void | qDeleteAll(ForwardIterator begin, ForwardIterator end) |
| void | qDeleteAll(const Container &c) |
(since 6.10) Result | qJoin(InputIterator first, InputIterator last, Result init, const Separator &separator = {}, Projection p = {}) |
| uint | qPopulationCount(quint8 v) |
| uint | qPopulationCount(quint16 v) |
| uint | qPopulationCount(quint32 v) |
| uint | qPopulationCount(quint64 v) |
Description détaillée
Qt fournit un certain nombre de fonctions modèles globales dans <QtAlgorithms> qui agissent sur des conteneurs et effectuent de petites tâches pour vous faciliter la vie, telles que qDeleteAll(), qui appelle operator delete sur tous les éléments d’un conteneur donné ou d’une plage donnée. Vous pouvez utiliser ces algorithmes avec n’importe quelle classe de conteneur fournissant des itérateurs de type STL, y compris les classes Qt QList, QMap et QHash.
La plupart des algorithmes prennent des itérateurs de type STL en paramètres. Ces algorithmes sont génériques dans le sens où ils ne sont pas liés à une classe d’itérateur spécifique ; vous pouvez les utiliser avec n’importe quel itérateur répondant à un certain ensemble d’exigences.
Les différents algorithmes peuvent avoir des exigences différentes concernant les itérateurs qu’ils acceptent. Les types d’itérateurs requis sont spécifiés pour chaque algorithme. Si un itérateur de type incorrect est passé (par exemple, si QList::ConstIterator est passé comme output iterator), vous obtiendrez toujours une erreur de compilation, bien qu’elle ne soit pas nécessairement très informative.
Certains algorithmes imposent des contraintes spécifiques concernant le type de valeur stocké dans les conteneurs. Par exemple, ` qDeleteAll()` exige que le type de valeur soit un type de pointeur non-const (par exemple, ` QWidget *`). Les contraintes relatives au type de valeur sont précisées pour chaque algorithme, et le compilateur générera une erreur si une contrainte n’est pas respectée.
Les algorithmes génériques peuvent être utilisés avec d’autres classes de conteneurs que celles fournies par Qt et la STL. La syntaxe des itérateurs de style STL s’inspire des pointeurs C++ ; il est donc possible d’utiliser des tableaux simples comme conteneurs et des pointeurs simples comme itérateurs.
Types d’itérateurs
Les algorithmes imposent certaines contraintes concernant les types d’itérateurs qu’ils acceptent ; celles-ci sont spécifiées individuellement pour chaque fonction. Le compilateur générera une erreur si une contrainte n’est pas respectée.
Itérateurs d’entrée
Un itérateur d’entrée est un itérateur qui peut être utilisé pour lire des données de manière séquentielle à partir d’un conteneur. Il doit fournir les opérateurs suivants : « == » et « != » pour comparer deux itérateurs, l’opérateur unaire « * » pour récupérer la valeur stockée dans l’élément, et l’opérateur préfixe « ++ » pour passer à l’élément suivant.
Les types d’itérateurs des conteneurs Qt (const et non const) sont tous des itérateurs d’entrée.
Itérateurs de sortie
Un itérateur de sortie est un itérateur pouvant être utilisé pour écrire des données de manière séquentielle dans un conteneur ou dans un flux de sortie. Il doit fournir les opérateurs suivants : l’opérateur unaire * pour écrire une valeur (c’est-à-dire *it = val) et l’opérateur préfixe ++ pour passer à l’élément suivant.
Les types d'itérateurs non-const des conteneurs Qt sont tous des itérateurs de sortie.
Itérateurs avant
Un itérateur direct est un itérateur qui répond à la fois aux exigences des itérateurs d’entrée et à celles des itérateurs de sortie.
Les types d'itérateurs non const des conteneurs Qt sont tous des itérateurs avant.
Itérateurs bidirectionnels
Un itérateur bidirectionnel est un itérateur qui répond aux exigences des itérateurs avant, mais qui prend en outre en charge l'-- préfixée pour l'itération vers l'arrière.
Les types d'itérateurs non-const des conteneurs Qt sont tous des itérateurs bidirectionnels.
Itérateurs à accès aléatoire
La dernière catégorie, celle des itérateurs à accès aléatoire, est le type d'itérateur le plus puissant. Elle répond à toutes les exigences d'un itérateur bidirectionnel et prend en charge les opérations suivantes :
i += n | fait avancer l’ i de l’itérateur de n positions |
i -= n | fait reculer l'i e de l'itérateur de n positions |
i + n ou n + i | renvoie l’itérateur correspondant à l’élément situé à n positions en avant de l’itérateur i |
i - n | renvoie l’itérateur correspondant à l’élément situé n positions en arrière de l’itérateur i |
i - j | renvoie le nombre d’éléments entre les itérateurs « i » et j |
i[n] | identique à *(i + n) |
i < j | renvoie l'true si l'j de l'itérateur se trouve après l'itérateur i |
QListest un itérateur à accès aléatoire.
Voir également les classes de conteneurs et <QtGlobal>.
Documentation des fonctions
[constexpr noexcept] uint qCountLeadingZeroBits(quint16 v)
Renvoie le nombre de bits zéro consécutifs dans ` v`, en commençant par le bit de poids fort (MSB). Par exemple, `qCountLeadingZeroBits(quint16(1))` renvoie 15 et `qCountLeadingZeroBits(quint16(8))` renvoie 12.
[constexpr noexcept] uint qCountLeadingZeroBits(quint32 v)
Renvoie le nombre de bits zéro consécutifs dans ` v`, en commençant par le bit de poids fort (MSB). Par exemple, `qCountLeadingZeroBits(quint32(1))` renvoie 31 et `qCountLeadingZeroBits(quint32(8))` renvoie 28.
[constexpr noexcept] uint qCountLeadingZeroBits(quint64 v)
Renvoie le nombre de bits zéro consécutifs dans ` v`, en commençant par le bit de poids fort (MSB). Par exemple, `qCountLeadingZeroBits(quint64(1))` renvoie 63 et `qCountLeadingZeroBits(quint64(8))` renvoie 60.
[constexpr noexcept] uint qCountLeadingZeroBits(quint8 v)
Renvoie le nombre de bits zéro consécutifs dans ` v`, en effectuant la recherche à partir du bit de poids fort (MSB). Par exemple, `qCountLeadingZeroBits(quint8(1))` renvoie 7 et `qCountLeadingZeroBits(quint8(8))` renvoie 4.
[constexpr noexcept] uint qCountTrailingZeroBits(quint8 v)
Renvoie le nombre de bits zéro consécutifs dans ` v`, en partant du bit de poids faible (LSB). Par exemple, `qCountTrailingZeroBits(1)` renvoie 0 et `qCountTrailingZeroBits(8)` renvoie 3.
[constexpr noexcept] uint qCountTrailingZeroBits(quint16 v)
Il s'agit d'une fonction surchargée.
[constexpr noexcept] uint qCountTrailingZeroBits(quint32 v)
Il s'agit d'une fonction surchargée.
[constexpr noexcept] uint qCountTrailingZeroBits(quint64 v)
Il s'agit d'une fonction surchargée.
template <typename ForwardIterator> void qDeleteAll(ForwardIterator begin, ForwardIterator end)
Supprime tous les éléments compris dans l'intervalle [begin, end) à l'aide de l'opérateur « delete » de C++. Le type des éléments doit être un type pointeur (par exemple, QWidget *).
Exemple :
QList<QColor *> list;
list.append(new QColor(Qt::blue));
list.append(new QColor(Qt::yellow));
qDeleteAll(list.begin(), list.end());
list.clear();Notez que qDeleteAll() ne supprime pas les éléments du conteneur ; elle se contente d’appeler la fonction delete sur ceux-ci. Dans l’exemple ci-dessus, nous appelons la fonction clear() sur le conteneur pour supprimer les éléments.
Cette fonction peut également être utilisée pour supprimer des éléments stockés dans des conteneurs associatifs, tels que QMap et QHash. Seuls les objets stockés dans chaque conteneur seront supprimés par cette fonction ; les objets utilisés comme clés ne seront pas supprimés.
Voir également forward iterators.
template <typename Container> void qDeleteAll(const Container &c)
Cela revient à appeler qDeleteAll(c.begin(), c.end()).
Il s'agit d'une fonction surchargée.
[since 6.10] template <
typename InputIterator,
typename Result,
typename Separator = Result,
typename Projection = std::identity
>
Result qJoin(InputIterator first, InputIterator last, Result init, const Separator &separator = {}, Projection p = {})
Commence par la valeur initiale init et y ajoute de manière cumulative chaque entrée comprise dans l'intervalle allant de first à last. Avant d'être ajoutée, chaque entrée est mappée via la projection p (qui est par défaut la projection identité). Entre chaque entrée et la suivante, un separator facultatif est ajouté. Par exemple :
QList<int> l = {1, 2, 3};
QString res = qJoin(l.cbegin(), l.cend(), QString(), u" / ",
[](int n) { return QString::number(2 * n);});
// res == "2 / 4 / 6"Remarque : ` q20::identity ` est un portage vers C++17 de la fonctionnalité de C++20 std::identity.
Cette fonction a été introduite dans Qt 6.10.
[constexpr noexcept] uint qPopulationCount(quint8 v)
Renvoie le nombre de bits à 1 dans ` v`. Ce nombre est également appelé « poids de Hamming » de ` v`.
[constexpr noexcept] uint qPopulationCount(quint16 v)
Il s'agit d'une fonction surchargée.
[constexpr noexcept] uint qPopulationCount(quint32 v)
Il s'agit d'une fonction surchargée.
[constexpr noexcept] uint qPopulationCount(quint64 v)
Il s'agit d'une fonction surchargée.
© 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.
