<QtAlgorithms> - Generic Algorithms
L'en-tête <QtAlgorithms> comprend les algorithmes génériques basés sur des modèles. 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 de modèle globales dans <QtAlgorithms> qui travaillent sur les conteneurs et effectuent de petites tâches pour faciliter la vie, comme qDeleteAll(), qui invoque 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 qui fournit des itérateurs de style STL, y compris les classes QList, QMap, et QHash.
La plupart des algorithmes prennent en paramètre des itérateurs de type STL. Les 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 nombre d'exigences.
Des algorithmes différents peuvent avoir des exigences différentes pour les itérateurs qu'ils acceptent. Les types d'itérateurs requis sont spécifiés pour chaque algorithme. Si un itérateur d'un type incorrect est transmis (par exemple, si QList::ConstIterator est transmis en tant que output iterator), vous obtiendrez toujours une erreur du compilateur, même si elle n'est pas nécessairement très informative.
Certains algorithmes ont des exigences particulières quant au type de valeur stocké dans les conteneurs. Par exemple, qDeleteAll() exige que le type de valeur soit un pointeur non-const (par exemple, QWidget *). Les exigences relatives au type de valeur sont spécifiées pour chaque algorithme, et le compilateur produira une erreur si une exigence n'est pas satisfaite.
Les algorithmes génériques peuvent être utilisés sur d'autres classes de conteneurs que celles fournies par Qt et STL. La syntaxe des itérateurs de style STL est calquée sur celle des pointeurs C++, de sorte qu'il est possible d'utiliser des tableaux simples comme conteneurs et des pointeurs simples comme itérateurs.
Types d'itérateurs
Les algorithmes ont certaines exigences concernant les types d'itérateurs qu'ils acceptent, et celles-ci sont spécifiées individuellement pour chaque fonction. Le compilateur produira une erreur si une condition n'est pas remplie.
Itérateurs d'entrée
Un itérateur d'entrée est un itérateur qui peut être utilisé pour lire des données séquentiellement à partir d'un conteneur. Il doit fournir les opérateurs suivants : == et != pour comparer deux itérateurs, * unaire pour récupérer la valeur stockée dans l'élément, et ++ 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 qui peut être utilisé pour écrire des données séquentiellement dans un conteneur ou dans un flux de sortie. Il doit fournir les opérateurs suivants : l'unaire * pour écrire une valeur (c'est-à-dire *it = val) et le préfixe ++ pour passer à l'élément suivant.
Les itérateurs non constants des conteneurs Qt sont tous des itérateurs de sortie.
Itérateurs forward
Un itérateur forward est un itérateur qui répond à la fois aux exigences des itérateurs d'entrée et des itérateurs de sortie.
Les types d'itérateurs non constants des conteneurs Qt sont tous des itérateurs forward.
Itérateurs bidirectionnels
Un itérateur bidirectionnel est un itérateur qui répond aux exigences des itérateurs forward mais qui supporte en plus le préfixe -- pour l'itération backward.
Les types d'itérateurs non constants des conteneurs Qt sont tous des itérateurs bidirectionnels.
Itérateurs à accès aléatoire
La dernière catégorie, les itérateurs à accès aléatoire, est le type d'itérateur le plus puissant. Il répond à toutes les exigences d'un itérateur bidirectionnel et prend en charge les opérations suivantes :
i += n | avance l'itérateur i de n positions |
i -= n | recule l'itérateur i de n positions |
i + n ou n + i | renvoie l'itérateur pour l'élément n qui précède l'itérateur i |
i - n | renvoie l'itérateur pour l'élément n positions derrière 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 true si l'itérateur j vient après l'itérateur i |
QListLe type d'itérateur non constant de iterator est un itérateur à accès aléatoire.
Voir également les classes de conteneurs et <QtGlobal>.
Documentation sur les fonctions
[constexpr noexcept] uint qCountLeadingZeroBits(quint16 v)
Renvoie le nombre de bits zéro consécutifs dans v, en effectuant une recherche à partir du 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 effectuant une recherche à partir du 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 effectuant une recherche à partir du 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 une recherche à partir du 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 effectuant une recherche à partir du 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 de l'intervalle [begin, end) à l'aide de l'opérateur C++ delete. Le type d'élément doit être un 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();
Remarquez que qDeleteAll() ne supprime pas les éléments du conteneur ; il appelle simplement delete sur eux. Dans l'exemple ci-dessus, nous appelons 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)
C'est la même chose que 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 avec la valeur initiale init et y ajoute de manière cumulative chaque entrée dans l'intervalle de first à last. Chaque entrée est, avant d'être ajoutée, mappée à travers la projection p (qui est par défaut l'identité). Entre chaque entrée et la suivante, une valeur facultative separator est ajoutée. 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"
Note : q20::identity est un rétro-portage C++17 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 définis dans v. Ce nombre est également appelé le 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.
