QStringTokenizer Class
template <typename Haystack, typename Needle> class QStringTokenizerLa clase QStringTokenizer divide las cadenas en tokens según los separadores indicados. Más información...
| Encabezado: | #include <QStringTokenizer> |
| CMake: | find_package(Qt6 REQUIRED COMPONENTS Core) target_link_libraries(mytarget PRIVATE Qt6::Core) |
| qmake: | QT += core |
| Desde: | Qt 6.0 |
| Heredado de: | QtPrivate::Tok::HaystackPinning (privado), QtPrivate::Tok::NeedlePinning (privado) y |
- Lista de todos los miembros, incluidos los heredados
- QStringTokenizer forma parte de las clases para datos de cadena.
Nota: Todas las funciones de esta clase son reentrantes.
Tipos públicos
| const_iterator | |
| const_pointer | |
| const_reference | |
| difference_type | |
| iterator | |
| pointer | |
| reference | |
| sentinel | |
| size_type | |
| value_type |
Funciones públicas
| 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 && |
Elementos no miembros relacionados
(since 6.0) auto | qTokenize(Haystack &&haystack, Needle &&needle, Flags... flags) |
Descripción detallada
QStringTokenizer<Haystack, Needle> es una clase de plantilla en la que Haystack es el tipo de la cadena que se va a tokenizar y Needle es el tipo del separador. En la práctica, nunca deberías tener que especificar estos argumentos de plantilla de forma explícita, ya que el compilador los deduce automáticamente.
Divide una cadena en subcadenas cada vez que aparece un separador determinado, devolviendo una lista (construida de forma diferida) de dichas cadenas. Si el separador no coincide en ningún punto de la cadena, genera una lista de un solo elemento que contiene dicha cadena. Si el separador está vacío, QStringTokenizer genera una cadena vacía, seguida de cada uno de los caracteres de la cadena y, a continuación, otra cadena vacía. Las dos enumeraciones Qt::SplitBehavior y Qt::CaseSensitivity controlan aún más la salida.
QStringTokenizer utiliza QStringView::tokenize(), pero también se puede utilizar directamente:
for (auto it : QStringTokenizer{string, separator})
use(*it);Nota: Nuncadebes nombrar explícitamente los argumentos de plantilla de un `QStringTokenizer`. Puedes escribir ` QStringTokenizer{string, separator} ` (sin argumentos de plantilla), o utilizar ` QStringView::tokenize()` o ` QLatin1StringView::tokenize()`, y luego almacenar el valor devuelto únicamente en una variable ` auto `:
auto result = strview.tokenize(sep);Esto se debe a que los argumentos de plantilla de QStringTokenizer tienen una dependencia muy sutil de los tipos específicos de cadena y separador a partir de los cuales se construyen, y no suelen corresponder a los tipos reales que se pasan.
Secuencias perezosas
QStringTokenizer actúa como lo que se denomina una secuencia perezosa, es decir, cada elemento siguiente solo se calcula cuando se solicita. Las secuencias perezosas tienen la ventaja de que solo requieren O(1) de memoria. Tienen la desventaja de que, al menos en el caso de QStringTokenizer, solo permiten la iteración hacia adelante, no el acceso aleatorio.
El caso de uso previsto es simplemente incorporarlo a un bucle «for» con rango:
for (auto it : QStringTokenizer{string, separator})
use(*it);o en un algoritmo de rango de C++20:
std::ranges::for_each(QStringTokenizer{string, separator},
[] (auto token) { use(token); });Sentinela de fin
Los iteradores de QStringTokenizer no se pueden utilizar con los algoritmos clásicos de la STL, ya que estos requieren pares de iteradores, mientras que QStringTokenizer utiliza centinelas. Es decir, utiliza un tipo diferente, QStringTokenizer::sentinel, para marcar el final del rango. Esto mejora el rendimiento, ya que el centinela es un tipo vacío. Los centinelas son compatibles a partir de C++17 (para el bucle «for» con rango) y C++20 (para los algoritmos que utilizan la nueva biblioteca de rangos).
Variables temporales
QStringTokenizer está diseñado con mucho cuidado para evitar referencias colgantes. Si creas un tokenizador a partir de una cadena temporal (un rvalue), ese argumento se almacena internamente, de modo que los datos a los que hace referencia no se eliminan antes de que se tokenicen:
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);Si pasas objetos con nombre (lvalues), QStringTokenizer no almacena una copia. Eres responsable de mantener los datos del objeto con nombre durante más tiempo del que el tokenizador tarda en procesarlos:
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);Véase también QStringView::split(), QString::split() y QRegularExpression.
Documentación sobre los tipos de miembros
[alias] QStringTokenizer::const_iterator
Este `typedef` proporciona un iterador `const` al estilo de la STL para ` QStringTokenizer`.
Véase también iterator.
[alias] QStringTokenizer::const_pointer
Alias de value_type *.
[alias] QStringTokenizer::const_reference
Alias de value_type &.
[alias] QStringTokenizer::difference_type
Alias de «qsizetype».
[alias] QStringTokenizer::iterator
Este `typedef` proporciona un iterador `const` al estilo de la STL para ` QStringTokenizer`.
QStringTokenizer No admite iteradores mutables, por lo que es equivalente a ` const_iterator`.
Véase también const_iterator.
[alias] QStringTokenizer::pointer
Alias de value_type *.
QStringTokenizer No admite iteradores mutables, por lo que es lo mismo que const_pointer.
[alias] QStringTokenizer::reference
Alias de value_type &.
QStringTokenizer No admite referencias mutables, por lo que es lo mismo que const_reference.
[alias] QStringTokenizer::sentinel
Este `typedef` proporciona un sentinela al estilo STL para QStringTokenizer::iterator y QStringTokenizer::const_iterator.
Véase también const_iterator.
[alias] QStringTokenizer::size_type
Alias de qsizetype.
[alias] QStringTokenizer::value_type
Alias de « const QStringView » o « const QLatin1StringView », dependiendo del argumento de plantilla « Haystack » del tokenizador.
Documentación de las funciones de miembro
[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)
Crea un tokenizador de cadenas que divide la cadena haystack en subcadenas cada vez que aparece needle, y permite recorrer esas cadenas a medida que se van encontrando. Si needle no coincide en ningún punto de haystack, se genera un único elemento que contiene haystack.
cs especifica si needle debe buscarse distinguiendo entre mayúsculas y minúsculas o sin distinguirlas.
Si sb es Qt::SkipEmptyParts, las entradas vacías no aparecen en el resultado. Por defecto, se incluyen las entradas vacías.
Nota: ( 1) es «noexcept» cuando ` std::is_nothrow_copy_constructible<QStringTokenizer>::value ` es ` true`.
Nota: ( 2) es «noexcept» cuando std::is_nothrow_copy_constructible<QStringTokenizer>::value es « true ».
Véase también QStringView::split(), QString::split(), Qt::CaseSensitivity y Qt::SplitBehavior.
[noexcept] QStringTokenizer<Haystack, Needle>::iterator QStringTokenizer::begin() const
[noexcept] QStringTokenizer<Haystack, Needle>::iterator QStringTokenizer::cbegin() const
Devuelve un iterador constante al estilo STL que apunta al primer token de la lista.
[constexpr noexcept] QStringTokenizer<Haystack, Needle>::sentinel QStringTokenizer::cend() const
Igual que end().
Véase también cbegin() y end().
[constexpr noexcept] QStringTokenizer<Haystack, Needle>::sentinel QStringTokenizer::end() const
Devuelve un sentinela constante al estilo STL que apunta al token imaginario situado después del último token de la lista.
Véase también begin() y cend().
template <typename LContainer> LContainer QStringTokenizer::toContainer(LContainer &&c = {}) const &
Convierte la secuencia «lazy» en un contenedor (normalmente) de acceso aleatorio de tipo LContainer.
Esta función solo está disponible si ` Container ` tiene un ` value_type ` que coincida con el ` value_type` de este tokenizador.
Si se pasa un contenedor con nombre (un lvalue) para ` c`, dicho contenedor se rellena y se devuelve una referencia al mismo. Si se pasa un contenedor temporal (un rvalue, incluido el argumento por defecto), dicho contenedor se rellena y se devuelve por valor.
// 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);Esto te ofrece la máxima flexibilidad a la hora de decidir cómo quieres que se almacene la secuencia.
template <typename RContainer> RContainer QStringTokenizer::toContainer(RContainer &&c = {}) const &&
Convierte la secuencia perezosa en un contenedor (normalmente) de acceso aleatorio de tipo ` RContainer`.
Además de las restricciones de la sobrecarga «lvalue-this», esta sobrecarga «rvalue-this» solo está disponible cuando este ` QStringTokenizer ` no almacena el «haystack» internamente, ya que esto podría crear un contenedor lleno de referencias colgantes:
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 deletedPara solucionarlo, almacena el ` QStringTokenizer ` en una variable temporal:
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.Puedes forzar la existencia de esta función pasando una vista en su lugar:
func(QStringTokenizer{QStringView{widget.text()}, u','}.toContainer());
// OK: compiler keeps widget.text() around until after func() has executedSi se pasa un contenedor con nombre (un lvalue) para ` c`, dicho contenedor se rellena y se devuelve una referencia al mismo. Si se pasa un contenedor temporal (un rvalue, incluido el argumento por defecto), dicho contenedor se rellena y se devuelve por valor.
Esta es una función sobrecargada.
Elementos no miembros relacionados
[constexpr noexcept(...), since 6.0] template <
typename Haystack,
typename Needle,
typename... Flags
>
auto qTokenize(Haystack &&haystack, Needle &&needle, Flags... flags)
Función de fábrica para un ` QStringTokenizer ` que divide la cadena ` haystack ` en subcadenas cada vez que aparece ` needle `, y permite iterar sobre esas cadenas a medida que se van encontrando. Si ` needle ` no coincide en ningún punto de ` haystack`, se genera un único elemento que contiene ` haystack `.
Pasa valores de los enumeradores Qt::CaseSensitivity y Qt::SplitBehavior como flags para modificar el comportamiento del tokenizador.
Esta función se introdujo en Qt 6.0.
Nota: Esta función es «noexcept» cuando QtPrivate::Tok::is_nothrow_constructible_from<Haystack, Needle>::value es true.
© 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.