QStringTokenizer Class

template <typename Haystack, typename Needle> class QStringTokenizer

Die Klasse QStringTokenizer zerlegt Zeichenketten in Token entlang vorgegebener Trennzeichen. Mehr...

Kopfzeile: #include <QStringTokenizer>
CMake: find_package(Qt6 REQUIRED COMPONENTS Core)
target_link_libraries(mytarget PRIVATE Qt6::Core)
qmake: QT += core
Seit: Qt 6.0
Erbt: QtPrivate::Tok::HaystackPinning (privat), QtPrivate::Tok::NeedlePinning (privat), und

Hinweis: Alle Funktionen in dieser Klasse sind reentrant.

Öffentliche Typen

Öffentliche Funktionen

QStringTokenizer(Haystack haystack, Needle needle, Qt::CaseSensitivity cs, Qt::SplitBehavior sb = Qt::KeepEmptyParts)
QStringTokenizer(Haystack haystack, Needle needle, Qt::SplitBehavior sb = Qt::KeepEmptyParts, Qt::CaseSensitivity cs = Qt::CaseSensitive)
QStringTokenizer<Haystack, Needle>::iterator begin() const
QStringTokenizer<Haystack, Needle>::iterator cbegin() const
QStringTokenizer<Haystack, Needle>::sentinel cend() const
QStringTokenizer<Haystack, Needle>::sentinel end() const
LContainer toContainer(LContainer &&c = {}) const &
RContainer toContainer(RContainer &&c = {}) const &&
(since 6.0) auto qTokenize(Haystack &&haystack, Needle &&needle, Flags... flags)

Detaillierte Beschreibung

Zerlegt eine Zeichenkette an allen Stellen, an denen ein bestimmtes Trennzeichen vorkommt, in Teilzeichenketten und gibt eine (träge konstruierte) Liste dieser Zeichenketten zurück. Wenn das Trennzeichen nirgendwo in der Zeichenkette vorkommt, wird eine Einzelelementliste erzeugt, die diese Zeichenkette enthält. Wenn das Trennzeichen leer ist, erzeugt QStringTokenizer eine leere Zeichenkette, gefolgt von jedem der Zeichen der Zeichenkette, gefolgt von einer weiteren leeren Zeichenkette. Die beiden Aufzählungen Qt::SplitBehavior und Qt::CaseSensitivity steuern die Ausgabe weiter.

QStringTokenizer steuert QStringView::tokenize(), aber Sie können es auch direkt verwenden:

for (auto it : QStringTokenizer{string, separator})
    use(*it);

Hinweis: Sie sollten niemals die Template-Argumente eines QStringTokenizers explizit benennen. Sie können QStringTokenizer{string, separator} (ohne Template-Argumente) schreiben, oder die Funktion qTokenize() oder die Mitgliedsfunktionen QStringView::split() oder QLatin1StringView::split() verwenden und den Rückgabewert nur in auto Variablen speichern:

auto result = string.split(sep);

Das liegt daran, dass die Template-Argumente von QStringTokenizer eine sehr subtile Abhängigkeit von den spezifischen String- und Separatortypen haben, aus denen sie konstruiert werden, und sie entsprechen normalerweise nicht den tatsächlich übergebenen Typen.

Faule Sequenzen

QStringTokenizer arbeitet als so genannte Lazy Sequence, d.h. jedes nächste Element wird nur dann berechnet, wenn es angefordert wird. Lazy Sequences haben den Vorteil, dass sie nur O(1) Speicher benötigen. Sie haben den Nachteil, dass sie, zumindest für QStringTokenizer, nur Vorwärtsiterationen und keine Iterationen mit zufälligem Zugriff erlauben.

Der beabsichtigte Anwendungsfall ist, dass man sie einfach in eine Ranged-for-Schleife einfügt:

for (auto it : QStringTokenizer{string, separator})
    use(*it);

oder einen C++20 ranged Algorithmus:

std::ranges::for_each(QStringTokenizer{string, separator},
                      [] (auto token) { use(token); });

Sentinel beenden

Die QStringTokenizer-Iteratoren können nicht mit klassischen STL-Algorithmen verwendet werden, da diese Iterator/Iterator-Paare benötigen, während QStringTokenizer Sentinels verwendet. Das heißt, er verwendet einen anderen Typ, QStringTokenizer::sentinel, um das Ende des Bereichs zu markieren. Dies verbessert die Leistung, da der Sentinel ein leerer Typ ist. Sentinels werden ab C++17 (für ranged for) und C++20 (für Algorithmen, die die neue ranges-Bibliothek verwenden) unterstützt.

Zeiträume

QStringTokenizer wurde sehr sorgfältig entworfen, um Dangling References zu vermeiden. Wenn Sie einen Tokenizer aus einem temporären String (einem rvalue) konstruieren, wird dieses Argument intern gespeichert, so dass die referenzierten Daten nicht gelöscht werden, bevor sie tokenisiert werden:

auto tok = QStringTokenizer{widget.text(), u','};
// return value of `widget.text()` is destroyed, but content was moved into `tok`
for (auto e : tok)
   use(e);

Wenn Sie benannte Objekte (lvalues) übergeben, dann speichert QStringTokenizer keine Kopie. Sie sind dafür verantwortlich, dass die Daten des benannten Objekts länger vorhanden sind, als der Tokenizer sie bearbeitet:

auto text = widget.text();
auto tok = QStringTokenizer{text, u','};
text.clear();      // destroy content of `text`
for (auto e : tok) // ERROR: `tok` references deleted data!
    use(e);

Siehe auch QStringView::split(), QString::split(), und QRegularExpression.

Dokumentation der Mitgliedstypen

[alias] QStringTokenizer::const_iterator

Dieses Typedef bietet einen STL-ähnlichen Konst-Iterator für QStringTokenizer.

Siehe auch iterator.

[alias] QStringTokenizer::const_pointer

Alias für value_type *.

[alias] QStringTokenizer::const_reference

Alias für value_type &.

[alias] QStringTokenizer::difference_type

Alias für qsizetype.

[alias] QStringTokenizer::iterator

Dieses Typedef bietet einen STL-ähnlichen konstanten Iterator für QStringTokenizer.

QStringTokenizer unterstützt keine veränderlichen Iteratoren, daher ist dies dasselbe wie const_iterator.

Siehe auch const_iterator.

[alias] QStringTokenizer::pointer

Alias für value_type *.

QStringTokenizer unterstützt keine veränderlichen Iteratoren, daher ist dies dasselbe wie const_pointer.

[alias] QStringTokenizer::reference

Alias für value_type &.

QStringTokenizer unterstützt keine veränderbaren Referenzen, daher ist dies dasselbe wie const_reference.

[alias] QStringTokenizer::sentinel

Dieser Typedef bietet einen STL-ähnlichen Sentinel für QStringTokenizer::iterator und QStringTokenizer::const_iterator.

Siehe auch const_iterator.

[alias] QStringTokenizer::size_type

Alias für qsizetype.

[alias] QStringTokenizer::value_type

Alias für const QStringView oder const QLatin1StringView, je nach dem Argument der Vorlage Haystack des Tokenizers.

Dokumentation der Mitgliedsfunktionen

[explicit constexpr noexcept(...)] QStringTokenizer::QStringTokenizer(Haystack haystack, Needle needle, Qt::CaseSensitivity cs, Qt::SplitBehavior sb = Qt::KeepEmptyParts)

[explicit constexpr noexcept(...)] QStringTokenizer::QStringTokenizer(Haystack haystack, Needle needle, Qt::SplitBehavior sb = Qt::KeepEmptyParts, Qt::CaseSensitivity cs = Qt::CaseSensitive)

Konstruiert einen Zeichenketten-Tokenizer, der die Zeichenkette haystack an allen Stellen, an denen needle vorkommt, in Teilzeichenketten zerlegt und eine Iteration über diese Zeichenketten ermöglicht, sobald sie gefunden werden. Wenn needle nirgendwo in haystack vorkommt, wird ein einzelnes Element erzeugt, das haystack enthält.

cs gibt an, ob needle unter Beachtung der Groß- und Kleinschreibung abgeglichen werden soll.

Wenn sb gleich Qt::SkipEmptyParts ist, erscheinen leere Einträge nicht im Ergebnis. Standardmäßig werden leere Einträge eingeschlossen.

Hinweis: (1) ist noexcept, wenn std::is_nothrow_copy_constructible<QStringTokenizer>::value true ist.

Hinweis: (2) ist noexcept, wenn std::is_nothrow_copy_constructible<QStringTokenizer>::value gleich true ist.

Siehe auch QStringView::split(), QString::split(), Qt::CaseSensitivity, und Qt::SplitBehavior.

[noexcept] QStringTokenizer<Haystack, Needle>::iterator QStringTokenizer::begin() const

[noexcept] QStringTokenizer<Haystack, Needle>::iterator QStringTokenizer::cbegin() const

Gibt einen Iterator im Stil von const STL zurück, der auf das erste Token in der Liste zeigt.

Siehe auch end() und cend().

[constexpr noexcept] QStringTokenizer<Haystack, Needle>::sentinel QStringTokenizer::cend() const

Dasselbe wie end().

Siehe auch cbegin() und end().

[constexpr noexcept] QStringTokenizer<Haystack, Needle>::sentinel QStringTokenizer::end() const

Gibt einen Sentinel im Stil von const STL zurück, der auf das imaginäre Token nach dem letzten Token in der Liste zeigt.

Siehe auch begin() und cend().

template <typename LContainer> LContainer QStringTokenizer::toContainer(LContainer &&c = {}) const &

Konvertiert die Lazy Sequence in einen (typischerweise) Random-Access-Container des Typs LContainer.

Diese Funktion ist nur verfügbar, wenn Container einen value_type hat, der mit dem value_type dieses Tokenizers übereinstimmt.

Wenn Sie einen benannten Container (einen l-Wert) für c übergeben, wird dieser Container gefüllt und ein Verweis auf ihn zurückgegeben. Wenn Sie einen temporären Container (einen r-Wert, einschließlich des Standardarguments) übergeben, wird dieser Container gefüllt und als Wert zurückgegeben.

// assuming tok's value_type is QStringView, then...
auto tok = QStringTokenizer{~~~};
// ... rac1 is a QList:
auto rac1 = tok.toContainer();
// ... rac2 is std::pmr::vector<QStringView>:
auto rac2 = tok.toContainer<std::pmr::vector<QStringView>>();
auto rac3 = QVarLengthArray<QStringView, 12>{};
// appends the token sequence produced by tok to rac3
//  and returns a reference to rac3 (which we ignore here):
tok.toContainer(rac3);

Dies gibt Ihnen die größtmögliche Flexibilität, wie die Sequenz gespeichert werden soll.

template <typename RContainer> RContainer QStringTokenizer::toContainer(RContainer &&c = {}) const &&

Dies ist eine überladene Funktion.

Konvertiert die Lazy Sequence in einen (typischerweise) Random-Access-Container vom Typ RContainer.

Zusätzlich zu den Einschränkungen für die lvalue-this-Überladung ist diese rvalue-this-Überladung nur verfügbar, wenn QStringTokenizer den Heuhaufen nicht intern speichert, da dies einen Container voller baumelnder Referenzen erzeugen könnte:

auto tokens = QStringTokenizer{widget.text(), u','}.toContainer();
// ERROR: cannot call toContainer() on rvalue
// 'tokens' references the data of the copy of widget.text()
// stored inside the QStringTokenizer, which has since been deleted

Um das zu beheben, speichern Sie die QStringTokenizer in einem temporären:

auto tokenizer = QStringTokenizer{widget.text90, u','};
auto tokens = tokenizer.toContainer();
// OK: the copy of widget.text() stored in 'tokenizer' keeps the data
// referenced by 'tokens' alive.

Sie können die Existenz dieser Funktion erzwingen, indem Sie stattdessen eine Ansicht übergeben:

func(QStringTokenizer{QStringView{widget.text()}, u','}.toContainer());
// OK: compiler keeps widget.text() around until after func() has executed

Wenn Sie einen benannten Container (einen l-Wert) für c übergeben, wird dieser Container gefüllt und ein Verweis auf ihn zurückgegeben. Wenn Sie einen temporären Container (einen r-Wert, einschließlich des Standardarguments) übergeben, wird dieser Container gefüllt und als Wert zurückgegeben.

Verwandte Nicht-Mitglieder

[constexpr noexcept(...), since 6.0] template <typename Haystack, typename Needle, typename... Flags> auto qTokenize(Haystack &&haystack, Needle &&needle, Flags... flags)

Fabrikfunktion für QStringTokenizer, die die Zeichenkette haystack in Teilzeichenketten aufteilt, wo immer needle vorkommt, und die Iteration über diese Zeichenketten ermöglicht, sobald sie gefunden werden. Wenn needle nirgendwo in haystack vorkommt, wird ein einzelnes Element mit haystack erzeugt.

Übergeben Sie Werte von Qt::CaseSensitivity und Qt::SplitBehavior als flags, um das Verhalten des Tokenizers zu ändern.

Diese Funktion wurde in Qt 6.0 eingeführt.

Hinweis: Diese Funktion ist noexcept, wenn QtPrivate::Tok::is_nothrow_constructible_from<Haystack, Needle>::value true ist.

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