En esta página

Clases para datos de tipo cadena

Resumen

Esta página ofrece una visión general de las clases de cadenas en Qt, en particular de la gran cantidad de contenedores de cadenas y de cómo utilizarlos de forma eficiente en código en el que el rendimiento es fundamental.

Las siguientes instrucciones para un uso eficiente están dirigidas a desarrolladores experimentados que trabajen en código en el que el rendimiento sea fundamental y que contenga una cantidad considerable de procesamiento de cadenas. Se trata, por ejemplo, de un analizador sintáctico o un generador de archivos de texto. En general, QString puede utilizarse en cualquier contexto y funcionará correctamente. También proporciona API para gestionar varias codificaciones (por ejemplo, QString::fromLatin1()). Para muchas aplicaciones, y especialmente cuando el procesamiento de cadenas de caracteres tiene una influencia insignificante en el rendimiento, QString será una solución sencilla y suficiente. Algunas funciones de Qt devuelven un QStringView. Si es necesario, se puede convertir en un QString con QStringView::toString().

Consejos útiles

Las tres reglas siguientes mejoran sustancialmente el manejo de cadenas sin aumentar demasiado la complejidad. Sigue estas reglas para obtener un rendimiento casi óptimo en la mayoría de los casos. Las dos primeras reglas se refieren a la codificación de literales de cadena y a su marcado en el código fuente. La tercera regla se refiere a las copias profundas al utilizar partes de una cadena.

  • Todas las cadenas que solo contengan caracteres ASCII (por ejemplo, mensajes de registro) pueden codificarse con Latin-1. Utiliza la función string literal "foo"_L1 . Sin este sufijo, se supone que las cadenas literales del código fuente están codificadas en UTF-8 y su procesamiento será más lento. En general, intenta utilizar la codificación más compacta, que en muchos casos es Latin-1.
  • Las cadenas visibles para el usuario suelen traducirse y, por lo tanto, se pasan a través de la función QObject::tr(). Esta función toma un literal de cadena (matriz de const char) y devuelve un QString con codificación UTF-16, tal y como exigen todos los elementos de la interfaz de usuario. Si no se utiliza la infraestructura de traducción, debes emplear la codificación UTF-16 en toda la aplicación. Utilice el literal de cadena u"foo" para crear literales de cadena UTF-16 o el literal específico de Qt u"foo"_s para crear directamente un QString.
  • Al procesar partes de un ` QString`, en lugar de copiar cada parte en su propio objeto ` QString `, crea objetos ` QStringView `. Estos se pueden volver a convertir a ` QString ` utilizando ` QStringView::toString()`, pero evita hacerlo en la medida de lo posible. Si las funciones devuelven ` QStringView`, lo más eficiente es seguir trabajando con esta clase, si es posible. La API es similar a una constante ` QString`.

Uso eficiente

Para utilizar las clases de cadenas de forma eficiente, es necesario comprender los tres conceptos siguientes:

  • Codificación
  • Contenedores con propiedad y sin propiedad
  • Literales

Codificación

En cuanto a la codificación, Qt admite UTF-16, UTF-8, Latin-1 (ISO 8859-1) y US-ASCII (que es el subconjunto común de Latin-1 y UTF-8) de una forma u otra.

  • Latin-1 es una codificación de caracteres que utiliza un solo byte por carácter, lo que la convierte en la codificación más eficiente, pero también en la más limitada.
  • UTF-8 es una codificación de caracteres de longitud variable que codifica todos los caracteres utilizando de uno a cuatro bytes. Es compatible con versiones anteriores de US-ASCII y es la codificación habitual para el código fuente y archivos similares. Qt da por hecho que el código fuente está codificado en UTF-8.
  • UTF-16 es una codificación de longitud variable que utiliza dos o cuatro bytes por carácter. Es la codificación habitual para el texto visible para el usuario en Qt.

Consulta la información sobre la compatibilidad con Unicode en Qt para obtener más detalles.

Se admiten otras codificaciones en forma de funciones individuales, como ` QString::fromUcs4()` o de las clases ` QStringConverter `. Además, Qt proporciona un contenedor de datos independiente de la codificación, ` QByteArray`, que resulta muy adecuado para almacenar datos binarios. ` QAnyStringView ` realiza un seguimiento de la codificación de la cadena subyacente y, por lo tanto, puede ofrecer una vista de cadenas con cualquiera de los estándares de codificación admitidos.

La conversión entre codificaciones es costosa; por lo tanto, evítala si es posible. Por otro lado, una codificación más compacta, especialmente para los literales de cadena, puede reducir el tamaño binario, lo que puede aumentar el rendimiento. Cuando las cadenas literales pueden expresarse en Latin-1, se logra un buen equilibrio entre estos factores contrapuestos, incluso si en algún momento hay que convertirlas a UTF-16. Cuando una cadena en Latin-1 debe convertirse a un « QString », la conversión se realiza de forma relativamente eficiente.

Funcionalidad

Las clases de cadenas pueden distinguirse además por la funcionalidad que admiten. Una distinción importante es si son propietarias —y, por tanto, controlan— sus datos o si simplemente hacen referencia a datos almacenados en otro lugar. Las primeras se denominan contenedores propietarios, y las segundas, contenedores no propietarios o vistas. Un tipo de contenedor no propietario suele limitarse a registrar un puntero al inicio de los datos y su tamaño, lo que lo hace ligero y económico, pero solo permanece válido mientras los datos sigan estando disponibles. Una cadena propietaria gestiona la memoria en la que almacena sus datos, lo que garantiza que estos permanezcan disponibles durante toda la vida útil del contenedor; sin embargo, su creación y destrucción conllevan los costes de asignación y liberación de memoria. Las vistas suelen admitir un subconjunto de las funciones de la cadena propietaria, sin la posibilidad de modificar los datos subyacentes.

Como resultado, las vistas de cadena son especialmente adecuadas para representar partes de cadenas más largas, por ejemplo, en un analizador sintáctico, mientras que las cadenas de propiedad son adecuadas para el almacenamiento persistente, como los miembros de una clase. Cuando una función devuelve una cadena que ha construido, por ejemplo, combinando fragmentos, debe devolver una cadena propietaria; pero cuando una función devuelve parte de una cadena almacenada de forma persistente, suele ser más adecuado utilizar una vista.

Ten en cuenta que los contenedores de propiedad en Qt comparten sus datos de forma implícita, lo que significa que también resulta eficiente pasar o devolver contenedores grandes por valor, aunque sea ligeramente menos eficiente que pasarlos por referencia debido al recuento de referencias. Si deseas hacer uso del mecanismo de intercambio implícito de datos de las clases de Qt, debes pasar la cadena como un contenedor de propiedad o como una referencia a uno de ellos. La conversión a una vista y viceversa siempre creará una copia adicional de los datos.

Por último, Qt proporciona clases para caracteres individuales, listas de cadenas y comparadores de cadenas. Estas clases están disponibles para la mayoría de los estándares de codificación compatibles con Qt, con algunas excepciones. Las clases especializadas, como QLocale o QTextBoundaryFinder, proporcionan funcionalidades de nivel superior. Estas clases de alto nivel suelen basarse en QString y su codificación UTF-16. Algunas clases son plantillas y funcionan con todas las clases de cadenas disponibles.

Literales

El estándar de C++ proporciona literales de cadena para crear cadenas en tiempo de compilación. Existen literales de cadena definidos por el lenguaje y literales definidos por Qt, los denominados literales definidos por el usuario. Un literal de cadena definido por C++ va entre comillas dobles y puede tener un prefijo que indica al compilador cómo interpretar su contenido. En el caso de Qt, el literal de cadena UTF-16 u"foo" es el más importante. Crea una cadena codificada en UTF-16 en tiempo de compilación, lo que evita tener que convertirla desde otra codificación en tiempo de ejecución. A partir de ella se pueden construir de forma fácil y eficiente « QStringView », de modo que se pueden pasar a funciones que acepten un argumento de tipo « QStringView » (o, como resultado, un « QAnyStringView »).

u"foo"_s Los literales definidos por el usuario tienen la misma forma que los definidos por C++, pero añaden un sufijo tras la comilla de cierre. La codificación sigue viniendo determinada por el prefijo, pero el literal resultante se utiliza para construir un objeto de algún tipo definido por el usuario. XML-PH-0000@deepl.internal para QString, "foo"_L1 para QLatin1StringView y u"foo"_ba para QByteArray. Estos se proporcionan mediante el uso de StringLiterals Namespace. Un literal de cadena simple de C++ "foo" se interpretará como UTF-8 y la conversión a QString y, por lo tanto, a UTF-16, resultará costosa. Cuando tengas literales de cadena en ASCII puro, utiliza "foo"_L1 para interpretarlos como Latin-1, lo que te permitirá disfrutar de las diversas ventajas descritas anteriormente.

Clases básicas de cadenas

La siguiente tabla ofrece una visión general de las clases de cadenas básicas para los distintos estándares de codificación de texto.

CodificaciónLiteral de cadena en C++Literal definido por el usuario en QtCarácter de C++Carácter de QtCadena propiaCadena no propia
Latin-1-""_L1-QLatin1Char-QLatin1StringView
UTF-8u8""-char8_t--QUtf8StringView
UTF-16u""u""_schar16_tQCharQStringQStringView
Binario/Nulo-""_bastd::byte-QByteArrayQByteArrayView
Flexiblecualquiera----QAnyStringView

Algunas de las entradas que faltan pueden sustituirse por tipos de C++ integrados y de la biblioteca estándar: una cadena codificada en Latin-1 o UTF-8 de propiedad propia puede ser un ` std::string ` o cualquier matriz de 8 bits ` char `. ` QStringView ` también puede hacer referencia a cualquier matriz de caracteres de 16 bits, como `std::u16string` o `std::wstring` en algunas plataformas.

Qt también proporciona listas especializadas para algunos de esos tipos, que son QStringList y QByteArrayView, así como comparadores, QLatin1StringMatcher y QByteArrayMatcher. Los comparadores también tienen versiones estáticas que se crean en tiempo de compilación, QStaticLatin1StringMatcher y QStaticByteArrayMatcher.

Cabe destacar además que:

  • QStringLiteral es una macro idéntica a ` u"foo"_s ` y está disponible sin el ` StringLiterals Namespace`. Se recomienda utilizar el literal de cadena moderno.
  • QLatin1String es un sinónimo de QLatin1StringView y existe por motivos de compatibilidad con versiones anteriores. No es una cadena de propiedad y podría eliminarse en futuras versiones.
  • QAnyStringView proporciona una vista de una cadena con cualquiera de las tres codificaciones admitidas. La codificación se almacena junto con la referencia a los datos. Esta clase es muy adecuada para crear interfaces que acepten una amplia gama de tipos de cadenas y codificaciones. A diferencia de otras clases, no se realiza ningún procesamiento directamente sobre ` QAnyStringView `. El procesamiento se lleva a cabo sobre el objeto subyacente ` QLatin1StringView`, ` QUtf8StringView ` o ` QStringView ` en la codificación correspondiente. Utiliza ` QAnyStringView::visit()` para hacer lo mismo en tus propias funciones que acepten esta clase como argumento.
  • No resulta sencillo construir un ` QLatin1StringView ` con caracteres no ASCII en un archivo de código fuente codificado en UTF-8, por lo que requiere un tratamiento especial; consulta la documentación de ` QLatin1StringView `.
  • QStringRef es una referencia a una parte de un « QString », disponible en el módulo Qt5Compat para garantizar la compatibilidad con versiones anteriores. Debe sustituirse por QStringView.

Hay más clases de alto nivel que proporcionan funcionalidad adicional y que funcionan principalmente con ` QString ` y, por lo tanto, con UTF-16. Estas son:

  • QRegularExpression, ` QRegularExpressionMatch ` y ` QRegularExpressionMatchIterator ` para trabajar con la coincidencia de patrones y expresiones regulares.
  • QLocale para convertir números y datos a cadenas y viceversa, de forma adecuada al idioma y la cultura del usuario.
  • QCollator y QCollatorSortKey para comparar cadenas de caracteres en función del idioma, el alfabeto o el territorio del usuario.
  • QTextBoundaryFinder para dividir el texto y prepararlo para la composición tipográfica de acuerdo con las normas Unicode.
  • QStringBuilder, una clase interna que mejorará sustancialmente el rendimiento de las concatenaciones de cadenas con el operador +; consulta la documentación de QString.

Algunas clases son plantillas o cuentan con una API flexible y funcionan con diversas clases de cadenas. Estas son

¿Qué clase de cadena se debe utilizar?

La recomendación general para el uso de clases de cadenas es:

  • Evita las copias y las asignaciones de memoria,
  • Evita las conversiones de codificación, y
  • Elegir la codificación más compacta.

Qt ofrece numerosas funcionalidades para evitar las asignaciones de memoria. La mayoría de los contenedores de Qt emplean el «compartir implícito» de sus datos. Para que el compartir implícito funcione, debe existir una cadena ininterrumpida de la misma clase: convertir de QString a QStringView y viceversa dará como resultado dos QStrings que no comparten sus datos. Por lo tanto, las funciones deben pasar sus datos como « QString » (funcionan tanto los valores como las referencias). No es posible extraer partes de una cadena con el intercambio implícito de datos. Para utilizar partes de una cadena más larga, recurre a las «string views», una forma explícita de intercambio de datos.

Las conversiones entre codificaciones pueden reducirse si se mantiene una codificación determinada. Los datos recibidos, por ejemplo en UTF-8, se almacenan y procesan mejor en UTF-8 si no se requiere ninguna conversión a otra codificación. Las comparaciones entre cadenas de la misma codificación son más rápidas, y lo mismo ocurre con la mayoría de las demás operaciones. Si las cadenas de una codificación determinada se comparan o se convierten a menudo a cualquier otra codificación, podría resultar beneficioso convertirlas y almacenarlas una sola vez. Algunas operaciones proporcionan numerosas sobrecargas (o una sobrecarga « QAnyStringView ») para admitir diversos tipos de cadenas y codificaciones, y deberían ser la segunda opción para optimizar el rendimiento, si no es viable utilizar la misma codificación. Las conversiones explícitas de codificación antes de llamar a una función deben ser el último recurso cuando no haya ninguna otra opción disponible. Latin-1 es una codificación muy sencilla y las operaciones entre Latin-1 y cualquier otra codificación son casi tan eficientes como las operaciones entre la misma codificación.

Se debe elegir la codificación más eficiente (de mayor a menor eficiencia: Latin-1, UTF-8, UTF-16) cuando no haya otras restricciones que determinen la codificación. Para la gestión de errores y el registro de eventos, QLatin1StringView suele ser suficiente. Las cadenas visibles para el usuario en Qt son siempre de tipo QString y, como tales, están codificadas en UTF-16. Por lo tanto, lo más eficaz es utilizar QStrings, QStringViews y QStringLiterals a lo largo de todo el ciclo de vida de una cadena visible para el usuario. La función QObject::tr() proporciona la codificación y el tipo correctos. Se debe utilizar QByteArray si la codificación no es relevante, por ejemplo, para almacenar datos binarios, o si se desconoce la codificación.

Clase String para crear una API

Clase «String» para una API óptima

Variables de miembro

Las variables miembro deben ser de un tipo propietario en casi todos los casos. Las vistas solo pueden utilizarse como variables miembro si se garantiza que el ciclo de vida de la cadena propietaria a la que se hace referencia supera el ciclo de vida del objeto.

Argumentos de función

Los argumentos de función deben ser vistas de cadena con una codificación adecuada en la mayoría de los casos. Se puede utilizar ` QAnyStringView ` como parámetro para admitir más de una codificación, y ` QAnyStringView::visit()` se puede utilizar internamente para ramificarse en funciones específicas para cada codificación. Si la función se limita a una única codificación, se debe utilizar ` QLatin1StringView`, ` QUtf8StringView`, ` QStringView ` o ` QByteArrayView `.

Si la función guarda el argumento en una cadena de propiedad (normalmente una función setter), lo más eficiente es utilizar la misma cadena de propiedad como argumento de la función para aprovechar la funcionalidad implícita de intercambio de datos de Qt. La cadena de propiedad se puede pasar como una referencia de tipo « const ». La sobrecarga de funciones con múltiples tipos de cadenas «owning» y «non-owning» puede dar lugar a ambigüedad en la sobrecarga y debe evitarse. Los tipos de cadenas «owning» en Qt pueden convertirse automáticamente a su versión «non-owning» o a QAnyStringView.

Valores de retorno

Las cadenas temporales deben devolverse como una cadena de propiedad, normalmente de tipo ` QString`. Si la cadena devuelta se conoce en tiempo de compilación, utilice ` u"foo"_s ` para construir la estructura ` QString ` en tiempo de compilación. Si se devuelven cadenas de propiedad existentes (por ejemplo, QString) desde una función en su totalidad (por ejemplo, una función getter), lo más eficiente es devolverlas por referencia. También pueden devolverse por valor para permitir la devolución de una cadena temporal en el futuro. El uso que hace Qt del uso compartido implícito evita el impacto en el rendimiento que suponen la asignación y la copia al devolver por valor.

Se pueden devolver partes de cadenas existentes de manera eficiente mediante una vista de cadena con la codificación adecuada; como ejemplo, véase QRegularExpressionMatch::capturedView(), que devuelve un QStringView.

Clase `String` para utilizar la API

Clase de cadena para llamar a una función

Para utilizar una API de Qt de forma eficiente, debes intentar que los tipos de los argumentos de las funciones coincidan. Si tus opciones son limitadas, Qt llevará a cabo diversas conversiones: las cadenas con propiedad se convierten implícitamente en cadenas sin propiedad, y las cadenas sin propiedad pueden crear sus contrapartes con propiedad; véase, por ejemplo, QStringView::toString(). Las conversiones de codificación se realizan de forma implícita en muchos casos, pero esto debe evitarse siempre que sea posible. Para evitar una conversión implícita accidental desde UTF-8, puedes activar la macro QT_NO_CAST_FROM_ASCII.

Si necesitas construir una cadena en tiempo de ejecución antes de pasarla a una función, necesitarás una cadena de propiedad y, por lo tanto, QString. Si el argumento de la función es QStringView o QAnyStringView, se convertirá de forma implícita.

Si la cadena se conoce en tiempo de compilación, hay margen para la optimización. Si la función acepta un « QString », debes crearla con « u"foo"_s » o la macro « QStringLiteral ». Si la función espera un « QStringView », lo mejor es construirla con un literal de cadena UTF-16 ordinario « u"foo" »; si se espera un « QLatin1StringView », constrúyela con « "foo"_L1 ». Si puedes elegir entre ambas, por ejemplo, si la función espera « QAnyStringView », utiliza la codificación más compacta, normalmente Latin-1.

QAnyStringView

Vista unificada de cadenas en Latin-1, UTF-8 o UTF-16 con un subconjunto de solo lectura de la API de QString

QByteArray

Matriz de bytes

QByteArrayList

Lista de matrices de bytes

QByteArrayMatcher

Almacena una secuencia de bytes que se puede comparar rápidamente en una matriz de bytes

QByteArrayView

Vista de una matriz de bytes con un subconjunto de solo lectura de la API de QByteArray

QChar

Carácter Unicode de 16 bits

QCollator

Compara cadenas según un algoritmo de colación localizado

QCollatorSortKey

Se puede utilizar para acelerar la colación de cadenas

QLatin1Char

Carácter ASCII/Latin-1 de 8 bits

QLatin1StringMatcher

Búsqueda optimizada de subcadenas en texto Latin-1

QLatin1StringView

Envoltura ligera en torno a un literal de cadena codificado en US-ASCII/Latin-1

QLocale

Convierte entre números y sus representaciones como cadenas en varios idiomas

QRegularExpression

Coincidencia de patrones mediante expresiones regulares

QRegularExpressionMatch

Resultados de la coincidencia de un objeto `QRegularExpression` con una cadena

QRegularExpressionMatchIterator

Iterador sobre los resultados de una coincidencia global de un objeto QRegularExpression con una cadena

QStaticByteArrayMatcher

Versión en tiempo de compilación de QByteArrayMatcher

QStaticLatin1StringMatcher

Versión en tiempo de compilación de QLatin1StringMatcher

QString

Cadena de caracteres Unicode

QStringConverter

Clase base para la codificación y decodificación de texto

QStringDecoder

Decodificador de texto basado en estados

QStringEncoder

Codificador de texto basado en estados

QStringList

Lista de cadenas

QStringMatcher

Almacena una secuencia de caracteres que se pueden comparar rápidamente en una cadena Unicode

QStringRef

Envoltura ligera alrededor de subcadenas de QString

QStringTokenizer

Divide las cadenas en tokens según los separadores indicados

QStringView

Vista unificada de cadenas UTF-16 con un subconjunto de solo lectura de la API de QString

QTextBoundaryFinder

Método para localizar los límites de texto Unicode en una cadena

QTextStream

Interfaz práctica para leer y escribir texto

QUtf8StringView

Vista unificada de las cadenas UTF-8 con un subconjunto de solo lectura de la API de QString

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