QStringTokenizer Class
template <typename Haystack, typename Needle> class QStringTokenizerDie Klasse „QStringTokenizer“ teilt Zeichenketten anhand vorgegebener Trennzeichen in Token auf. Mehr...
| Header: | #include <QStringTokenizer> |
| CMake: | find_package(Qt6 REQUIRED COMPONENTS Core) target_link_libraries(mytarget PRIVATE Qt6::Core) |
| qmake: | QT += core |
| Seit: | Qt 6.0 |
| Erbt von: | QtPrivate::Tok::HaystackPinning (privat), QtPrivate::Tok::NeedlePinning (privat) und |
- Liste aller Mitglieder, einschließlich geerbter Mitglieder
- QStringTokenizer ist Teil der Klassen für Zeichenfolgendaten.
Hinweis: Alle Funktionen dieser Klasse sind reentrant.
Öffentliche Typen
| const_iterator | |
| const_pointer | |
| const_reference | |
| difference_type | |
| iterator | |
| pointer | |
| reference | |
| sentinel | |
| size_type | |
| value_type |
Ö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 && |
Verwandte Nicht-Mitglieder
(since 6.0) auto | qTokenize(Haystack &&haystack, Needle &&needle, Flags... flags) |
Ausführliche Beschreibung
QStringTokenizer<Haystack, Needle> ist eine Template-Klasse, wobei „ Haystack “ der Typ der zu tokenisierenden Zeichenkette und „ Needle “ der Typ des Trennzeichens ist. In der Praxis sollten Sie diese Template-Argumente niemals explizit angeben müssen; sie werden vom Compiler automatisch abgeleitet.
Teilt eine Zeichenkette an allen Stellen, an denen ein bestimmtes Trennzeichen vorkommt, in Teilzeichenketten auf und gibt eine (verzögert erzeugte) Liste dieser Zeichenketten zurück. Wenn das Trennzeichen an keiner Stelle in der Zeichenkette vorkommt, wird eine Liste mit einem Element erzeugt, die diese Zeichenkette enthält. Ist das Trennzeichen leer, erzeugt `QStringTokenizer` eine leere Zeichenkette, gefolgt von jedem einzelnen Zeichen der Zeichenkette und anschließend einer weiteren leeren Zeichenkette. Die beiden Aufzählungen ` Qt::SplitBehavior ` und ` Qt::CaseSensitivity ` steuern die Ausgabe zusätzlich.
QStringTokenizer steuert ` QStringView::tokenize()` an, aber Sie können diese Funktion auch direkt verwenden:
for (auto it : QStringTokenizer{string, separator})
use(*it);Hinweis: Sie sollten die Template-Argumente eines `QStringTokenizer` niemals explizit benennen. Sie können entweder ` QStringTokenizer{string, separator} ` (ohne Template-Argumente) schreiben oder entweder ` QStringView::tokenize()` oder ` QLatin1StringView::tokenize()` verwenden und den Rückgabewert anschließend ausschließlich in einer ` auto `-Variablen speichern:
auto result = strview.tokenize(sep);Der Grund dafür ist, dass die Template-Argumente von `QStringTokenizer` eine sehr subtile Abhängigkeit von den spezifischen String- und Trennzeichen-Typen aufweisen, aus denen sie konstruiert werden, und dass sie in der Regel nicht den tatsächlich übergebenen Typen entsprechen.
Lazy-Sequenzen
QStringTokenizer verhält sich wie eine sogenannte „lazy sequence“, d. h., jedes nächste Element wird erst berechnet, wenn Sie es anfordern. Lazy Sequences haben den Vorteil, dass sie nur O(1)-Speicherplatz benötigen. Ihr Nachteil ist, dass sie – zumindest bei QStringTokenizer – nur eine vorwärtsgerichtete Iteration zulassen, keinen wahlfreien Zugriff.
Der vorgesehene Anwendungsfall ist, dass man sie einfach in eine for-Schleife mit Bereichsangabe einbindet:
for (auto it : QStringTokenizer{string, separator})
use(*it);oder in einen C++20-Bereichsalgorithmus:
std::ranges::for_each(QStringTokenizer{string, separator},
[] (auto token) { use(token); });End-Sentinel
Die Iteratoren von QStringTokenizer können nicht mit klassischen STL-Algorithmen verwendet werden, da diese Iterator-/Iterator-Paare erfordern, während QStringTokenizer Sentinel-Werte verwendet. Das heißt, es 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.
Temporäre Variablen
QStringTokenizer wurde sehr sorgfältig entwickelt, um hängende Referenzen zu vermeiden. Wenn Sie einen Tokenizer aus einer temporären Zeichenkette (einem r-Wert) erstellen, wird dieses Argument intern gespeichert, sodass 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 (L-Werte) übergeben, speichert QStringTokenizer keine Kopie. Sie sind dafür verantwortlich, die Daten des benannten Objekts länger aufrechtzuerhalten, als der Tokenizer darauf zugreift:
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 zu Mitgliedstypen
[alias] QStringTokenizer::const_iterator
Dieser `typedef` stellt einen `const`-Iterator im STL-Stil für ` QStringTokenizer` bereit.
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
Diese `typedef`-Definition stellt einen `const`-Iterator im STL-Stil für ` QStringTokenizer` bereit.
QStringTokenizer Da ` const_iterator` keine veränderbare Iteratoren unterstützt, entspricht dies ` `.
Siehe auch const_iterator.
[alias] QStringTokenizer::pointer
Alias für value_type *.
QStringTokenizer unterstützt keine veränderbare Iteratoren, daher entspricht dies const_pointer.
[alias] QStringTokenizer::reference
Alias für value_type &.
QStringTokenizer unterstützt keine veränderbare Referenz, daher entspricht dies „ const_reference “.
[alias] QStringTokenizer::sentinel
Dieser `typedef` stellt einen Sentinel im STL-Stil für ` QStringTokenizer::iterator ` und ` QStringTokenizer::const_iterator` bereit.
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 Template-Argument „ Haystack “ des Tokenizers.
Dokumentation der Member-Funktionen
[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)
Erstellt einen String-Tokenizer, der die Zeichenfolge „ haystack “ an allen Stellen, an denen „ needle “ vorkommt, in Teilzeichenfolgen aufteilt und das Durchlaufen dieser gefundenen Zeichenfolgen ermöglicht. Wenn „ needle “ an keiner Stelle in „ haystack “ vorkommt, wird ein einzelnes Element erzeugt, das „ haystack “ enthält.
cs Legt fest, ob bei der Suche nach „ needle “ die Groß-/Kleinschreibung beachtet werden soll oder nicht.
Wenn sb gleich Qt::SkipEmptyParts ist, erscheinen keine leeren Einträge im Ergebnis. Standardmäßig werden leere Einträge einbezogen.
Hinweis: ( 1) gilt nicht, wenn std::is_nothrow_copy_constructible<QStringTokenizer>::value auf „ true “ gesetzt ist.
Hinweis: ( 2) ist „noexcept“, wenn „ std::is_nothrow_copy_constructible<QStringTokenizer>::value “ „ 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 konstanten Iterator im STL-Stil 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
Wie unter end() beschrieben.
Siehe auch cbegin() und end().
[constexpr noexcept] QStringTokenizer<Haystack, Needle>::sentinel QStringTokenizer::end() const
Gibt einen konstanen Sentinel im STL-Stil 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 &
Wandelt die „lazy“-Sequenz in einen (in der Regel) direkt zugänglichen Container vom Typ „ LContainer “ um.
Diese Funktion ist nur verfügbar, wenn „ Container “ über eine „ value_type “ verfügt, die mit der „ value_type “ dieses Tokenizers übereinstimmt.
Wenn Sie einen benannten Container (ein l-Wert) für ` c` übergeben, wird dieser Container gefüllt und eine Referenz darauf zurückgegeben. Wenn Sie einen temporären Container (ein 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 bietet Ihnen maximale Flexibilität hinsichtlich der Art und Weise, wie die Sequenz gespeichert werden soll.
template <typename RContainer> RContainer QStringTokenizer::toContainer(RContainer &&c = {}) const &&
Wandelt die „lazy“-Sequenz in einen (in der Regel) direkt zugänglichen Container vom Typ „ RContainer “ um.
Zusätzlich zu den Einschränkungen der L-Wert-„this“-Überladung ist diese R-Wert-„this“-Überladung nur verfügbar, wenn dieser ` QStringTokenizer ` den Heuhaufen nicht intern speichert, da dies zu einem Container voller hängender Referenzen führen 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 deletedUm dies zu beheben, speichern Sie den ` QStringTokenizer ` in einer temporären Variablen:
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 Ausführung 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 executedWenn Sie einen benannten Container (ein L-Wert) als ` c` übergeben, wird dieser Container gefüllt und eine Referenz darauf zurückgegeben. Wenn Sie einen temporären Container (ein R-Wert, einschließlich des Standardarguments) übergeben, wird dieser Container gefüllt und als Wert zurückgegeben.
Dies ist eine überladene Funktion.
Verwandte Nicht-Mitglieder
[constexpr noexcept(...), since 6.0] template <
typename Haystack,
typename Needle,
typename... Flags
>
auto qTokenize(Haystack &&haystack, Needle &&needle, Flags... flags)
Werksfunktion für ein „ QStringTokenizer “, die die Zeichenkette „ haystack “ an allen Stellen, an denen „ needle “ vorkommt, in Teilzeichenketten aufteilt und eine Iteration über diese Zeichenketten ermöglicht, sobald sie gefunden werden. Wenn „ needle “ an keiner Stelle in „ haystack “ vorkommt, wird ein einzelnes Element erzeugt, das „ haystack “ enthält.
Übergeben Sie Werte aus den Enumeratoren „ Qt::CaseSensitivity “ und „ Qt::SplitBehavior “ als „ flags “, um das Verhalten des Tokenizers anzupassen.
Diese Funktion wurde in Qt 6.0 eingeführt.
Hinweis: Diese Funktion ist `noexcept`, wenn ` QtPrivate::Tok::is_nothrow_constructible_from<Haystack, Needle>::value ` gleich ` true` ist.
© 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.