<QtAlgorithms> - Generic Algorithms
Der Header <QtAlgorithms> enthält die generischen, auf Vorlagen basierenden Algorithmen. Mehr...
| Header: | #include <QtAlgorithms> |
Funktionen
| 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) |
Ausführliche Beschreibung
Qt stellt in „ <QtAlgorithms> “ eine Reihe globaler Template-Funktionen bereit, die auf Containern arbeiten und kleine Aufgaben übernehmen, um die Arbeit zu erleichtern, wie beispielsweise „ qDeleteAll()“, das „ operator delete “ für alle Elemente in einem bestimmten Container oder in einem bestimmten Bereich aufruft. Sie können diese Algorithmen mit jeder Containerklasse verwenden, die Iteratoren im STL-Stil bereitstellt, einschließlich der Qt-Klassen „ QList “, „ QMap “ und „ QHash “.
Die meisten Algorithmen nehmen Iteratoren im STL-Stil als Parameter entgegen. Die Algorithmen sind insofern generisch, als sie nicht an eine bestimmte Iteratorklasse gebunden sind; Sie können sie mit beliebigen Iteratoren verwenden, die bestimmte Anforderungen erfüllen.
Verschiedene Algorithmen können unterschiedliche Anforderungen an die von ihnen akzeptierten Iteratoren stellen. Die erforderlichen Iteratortypen werden für jeden Algorithmus angegeben. Wird ein Iterator des falschen Typs übergeben (beispielsweise wenn ` QList::ConstIterator ` als ` output iterator` übergeben wird), erhalten Sie stets einen Compilerfehler, der jedoch nicht unbedingt sehr aussagekräftig ist.
Einige Algorithmen stellen spezielle Anforderungen an den in den Containern gespeicherten Werttyp. Beispielsweise erfordert ` qDeleteAll()` einen Werttyp, der ein nicht-konstanter Zeigertyp ist (z. B. ` QWidget *`). Die Anforderungen an den Werttyp werden für jeden Algorithmus angegeben, und der Compiler gibt eine Fehlermeldung aus, wenn eine Anforderung nicht erfüllt ist.
Die generischen Algorithmen können auch auf anderen Containerklassen als den von Qt und STL bereitgestellten angewendet werden. Die Syntax der Iteratoren im STL-Stil orientiert sich an C++-Zeigern, sodass es möglich ist, einfache Arrays als Container und einfache Zeiger als Iteratoren zu verwenden.
Arten von Iteratoren
Die Algorithmen stellen bestimmte Anforderungen an die von ihnen akzeptierten Iteratortypen, die für jede Funktion einzeln festgelegt sind. Der Compiler gibt eine Fehlermeldung aus, wenn eine Anforderung nicht erfüllt ist.
Eingabe-Iteratoren
Ein Eingabeiterator ist ein Iterator, der zum sequenziellen Auslesen von Daten aus einem Container verwendet werden kann. Er muss die folgenden Operatoren bereitstellen: „ == “ und „ != “ zum Vergleichen zweier Iteratoren, den unären Operator „ * “ zum Abrufen des im Element gespeicherten Werts sowie den Präfixoperator „ ++ “ zum Springen zum nächsten Element.
Die Iterator-Typen der Qt-Container (const und non-const) sind allesamt Eingabe-Iteratoren.
Ausgabeiteratoren
Ein Ausgabiterator ist ein Iterator, der zum sequenziellen Schreiben von Daten in einen Container oder einen Ausgabestrom verwendet werden kann. Er muss die folgenden Operatoren bereitstellen: den unären Operator ` * ` zum Schreiben eines Werts (d. h. ` *it = val`) und den Präfixoperator ` ++ ` zum Springen zum nächsten Element.
Die nicht-konstanten Iterator-Typen der Qt-Container sind allesamt Ausgabeiteratoren.
Vorwärtsiteratoren
Ein Vorwärtsiterator ist ein Iterator, der sowohl die Anforderungen an Eingabeiteratoren als auch an Ausgabeiteratoren erfüllt.
Die nicht-konstanten Iteratortypen der Qt-Container sind alle Vorwärtsiteratoren.
Bidirektionale Iteratoren
Ein bidirektionaler Iterator ist ein Iterator, der die Anforderungen an Vorwärtsiteratoren erfüllt, aber zusätzlich Präfix- -- en für das Zurückiterieren unterstützt.
Die nicht-konstanten Iteratortypen der Qt-Container sind alle bidirektionale Iteratoren.
Iteratoren mit wahlfreiem Zugriff
Die letzte Kategorie, die Iteratoren mit wahlfreiem Zugriff, stellt die leistungsstärkste Art von Iteratoren dar. Sie erfüllt alle Anforderungen eines bidirektionalen Iterators und unterstützt die folgenden Operationen:
i += n | verschiebt die Iterator i um n Positionen vorwärts |
i -= n | versetzt die Iterator- i um n Positionen zurück |
i + n oder n + i | gibt den Iterator für das Element zurück, das sich n Positionen vor dem Iterator befindet i |
i - n | gibt den Iterator für das Element zurück, das n Positionen hinter dem Iterator liegt i |
i - j | gibt die Anzahl der Elemente zwischen den Iteratoren „ i “ und j |
i[n] | entspricht *(i + n) |
i < j | gibt den true zurück, wenn der Iterator j nach dem Iterator kommt i |
QListder nicht-konstante Iteratortyp von `'` ein Iterator mit wahlfreiem Zugriff ist.
Siehe auch Containerklassen und <QtGlobal>.
Funktionsdokumentation
[constexpr noexcept] uint qCountLeadingZeroBits(quint16 v)
Gibt die Anzahl aufeinanderfolgender Nullbits in ` v` zurück, beginnend mit dem höchstwertigen Bit (MSB). Beispielsweise gibt `qCountLeadingZeroBits(quint16(1))` den Wert 15 zurück und `qCountLeadingZeroBits(quint16(8))` den Wert 12.
[constexpr noexcept] uint qCountLeadingZeroBits(quint32 v)
Gibt die Anzahl aufeinanderfolgender Null-Bits in ` v` zurück, wobei die Suche vom MSB aus erfolgt. Beispielsweise gibt `qCountLeadingZeroBits(quint32(1))` den Wert 31 zurück und `qCountLeadingZeroBits(quint32(8))` den Wert 28.
[constexpr noexcept] uint qCountLeadingZeroBits(quint64 v)
Gibt die Anzahl aufeinanderfolgender Nullbits in ` v` zurück, beginnend mit dem höchstwertigen Bit (MSB). Beispielsweise gibt `qCountLeadingZeroBits(quint64(1))` den Wert 63 und `qCountLeadingZeroBits(quint64(8))` den Wert 60 zurück.
[constexpr noexcept] uint qCountLeadingZeroBits(quint8 v)
Gibt die Anzahl aufeinanderfolgender Null-Bits in ` v` zurück, beginnend mit dem MSB. Beispielsweise gibt `qCountLeadingZeroBits(quint8(1))` den Wert 7 zurück und `qCountLeadingZeroBits(quint8(8))` den Wert 4.
[constexpr noexcept] uint qCountTrailingZeroBits(quint8 v)
Gibt die Anzahl aufeinanderfolgender Null-Bits in ` v` zurück, beginnend mit dem LSB. Beispielsweise gibt `qCountTrailingZeroBits(1)` den Wert 0 und `qCountTrailingZeroBits(8)` den Wert 3 zurück.
[constexpr noexcept] uint qCountTrailingZeroBits(quint16 v)
Dies ist eine überladene Funktion.
[constexpr noexcept] uint qCountTrailingZeroBits(quint32 v)
Dies ist eine überladene Funktion.
[constexpr noexcept] uint qCountTrailingZeroBits(quint64 v)
Dies ist eine überladene Funktion.
template <typename ForwardIterator> void qDeleteAll(ForwardIterator begin, ForwardIterator end)
Löscht alle Elemente im Bereich [begin, end) mithilfe des C++-Operators „ delete “. Der Elementtyp muss ein Zeigertyp sein (z. B. QWidget *).
Beispiel:
QList<QColor *> list;
list.append(new QColor(Qt::blue));
list.append(new QColor(Qt::yellow));
qDeleteAll(list.begin(), list.end());
list.clear();Beachten Sie, dass qDeleteAll() die Elemente nicht aus dem Container entfernt, sondern lediglich die Funktion ` delete ` für diese aufruft. Im obigen Beispiel rufen wir die Funktion `clear()` für den Container auf, um die Elemente zu entfernen.
Diese Funktion kann auch zum Löschen von Elementen verwendet werden, die in assoziativen Containern wie „ QMap “ und „ QHash “ gespeichert sind. Nur die in den jeweiligen Containern gespeicherten Objekte werden durch diese Funktion gelöscht; Objekte, die als Schlüssel verwendet werden, werden nicht gelöscht.
Siehe auch forward iterators.
template <typename Container> void qDeleteAll(const Container &c)
Dies entspricht qDeleteAll(c.begin(), c.end()).
Dies ist eine überladene Funktion.
[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 = {})
Beginnt mit dem Anfangswert init und addiert kumulativ jeden Eintrag im Bereich von first bis last dazu. Jeder Eintrag wird vor der Addition durch die Projektion p abgebildet (die standardmäßig die Identitätsabbildung ist). Zwischen jedem Eintrag und dem nächsten wird ein optionaler separator hinzugefügt. Zum Beispiel:
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"Hinweis: ` q20::identity ` ist ein C++17-Backport von C++20s std::identity.
Diese Funktion wurde in Qt 6.10 eingeführt.
[constexpr noexcept] uint qPopulationCount(quint8 v)
Gibt die Anzahl der gesetzten Bits in ` v` zurück. Diese Zahl wird auch als Hamming-Gewicht von ` v` bezeichnet.
[constexpr noexcept] uint qPopulationCount(quint16 v)
Dies ist eine überladene Funktion.
[constexpr noexcept] uint qPopulationCount(quint32 v)
Dies ist eine überladene Funktion.
[constexpr noexcept] uint qPopulationCount(quint64 v)
Dies ist eine überladene Funktion.
© 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.
