Clases para datos de cadena

Visión general

Esta página da una visión general sobre las clases string en Qt, en particular la gran cantidad de contenedores string y cómo usarlos eficientemente en código de rendimiento crítico.

Las siguientes instrucciones para un uso eficiente están dirigidas a desarrolladores experimentados que trabajan en código de rendimiento crítico que contiene cantidades considerables 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 lugar y funcionará correctamente. También proporciona APIs para manejar varias codificaciones (por ejemplo QString::fromLatin1()). Para muchas aplicaciones y especialmente cuando el procesamiento de cadenas juega un papel insignificante para el rendimiento, QString será una solución simple y suficiente. Algunas funciones Qt devuelven un QStringView. Si es necesario, puede convertirse a un QString con QStringView::toString().

Consejos impactantes

Las tres reglas siguientes mejoran sustancialmente el manejo de cadenas sin aumentar demasiado la complejidad. Siga 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 trata de las copias en profundidad cuando se utilizan partes de una cadena.

• Todas las cadenas que sólo contengan caracteres ASCII (por ejemplo, mensajes de registro) pueden codificarse con Latin-1. Utilice el sufijo string literal "foo"_L1 . Sin este sufijo, se asume que los literales de cadena en el código fuente están codificados en UTF-8 y su procesamiento será más lento. En general, intente utilizar la codificación más estricta, que en muchos casos es Latin-1.
• Las cadenas visibles para el usuario suelen traducirse y, por tanto, pasarse a través de la función QObject::tr(). Esta función toma un literal de cadena (const char array) y devuelve un QString con la codificación UTF-16 que exigen todos los elementos de la interfaz de usuario. Si no se utiliza la infraestructura de traducción, se debe utilizar 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, cree objetos QStringView. Éstos pueden convertirse de nuevo a QString utilizando QStringView::toString(), pero evite hacerlo en la medida de lo posible. Si las funciones devuelven QStringView, es más eficiente seguir trabajando con esta clase, si es posible. La API es similar a una constante QString.

Uso eficiente

Para usar eficientemente las clases string, uno debe entender los tres conceptos de:

• Codificación
• Contenedores propietarios y no propietarios
• Literales

Codificación

Qt soporta codificación 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 único byte por carácter, lo que la convierte en la más eficiente, aunque también 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 US-ASCII y es la codificación común para código fuente y archivos similares. Qt asume 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 común para el texto expuesto por el usuario en Qt.

Consulta la información sobre soporte para Unicode en Qt para más información.

Otras codificaciones están soportadas en forma de funciones individuales como QString::fromUcs4() o de las clases QStringConverter. Además, Qt proporciona un contenedor de datos agnóstico a la codificación, QByteArray, que es muy adecuado para almacenar datos binarios. QAnyStringView mantiene un registro de la codificación de la cadena subyacente y por lo tanto puede llevar una vista a cadenas con cualquiera de los estándares de codificación soportados.

La conversión entre codificaciones es costosa, por lo que debe evitarse en la medida de lo posible. Por otra parte, una codificación más compacta, en particular para los literales de cadena, puede reducir el tamaño binario, lo que puede aumentar el rendimiento. Cuando los literales de cadena pueden expresarse en Latin-1, se consigue un buen compromiso entre estos factores contrapuestos, incluso si tiene que convertirse a UTF-16 en algún momento. Cuando una cadena Latin-1 debe convertirse a QString, se hace de forma relativamente eficiente.

Funcionalidad

Las clases de cadenas pueden distinguirse además por la funcionalidad que soportan. Una distinción importante es si poseen, y por tanto controlan, sus datos o simplemente hacen referencia a datos que se encuentran 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 barato, pero sólo es válido mientras los datos sigan disponibles. Una cadena propietaria gestiona la memoria en la que almacena sus datos, asegurando que los datos permanezcan disponibles durante toda la vida útil del contenedor, pero su creación y destrucción incurren en los costes de asignar y liberar memoria. Las vistas suelen soportar un subconjunto de las funciones de la cadena propietaria, careciendo de la posibilidad de modificar los datos subyacentes.

Como resultado, las vistas de cadena son particularmente adecuadas para representar partes de cadenas más grandes, por ejemplo en un analizador sintáctico, mientras que las cadenas propias son buenas para el almacenamiento persistente, como los miembros de una clase. Cuando una función devuelve una cadena que ha construido, por ejemplo combinando fragmentos, tiene que devolver una cadena propia; pero cuando una función devuelve parte de alguna cadena almacenada persistentemente, una vista suele ser más adecuada.

Ten en cuenta que los contenedores propios en Qt comparten sus datos implícitamente, lo que significa que también es eficiente pasar o devolver grandes contenedores por valor, aunque ligeramente menos eficiente que pasar por referencia debido al conteo de referencias. Si quieres hacer uso del mecanismo implícito de compartición de datos de las clases Qt, tienes que pasar la cadena como un contenedor propietario o una referencia a uno. 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 emparejadores de cadenas. Estas clases están disponibles para la mayoría de los estándares de codificación soportados en Qt, con algunas excepciones. La funcionalidad de alto nivel es proporcionada por clases especializadas, como QLocale o QTextBoundaryFinder. Estas clases de alto nivel normalmente dependen de QString y su codificación UTF-16. Algunas clases son plantillas y funcionan con todas las clases de cadenas disponibles.

Literales

El estándar C++ proporciona literales de cadena para crear cadenas en tiempo de compilación. Hay literales de cadena definidos por el lenguaje y literales definidos por Qt, llamados literales definidos por el usuario. Un literal de cadena definido por C++ está encerrado entre comillas dobles y puede tener un prefijo que indica al compilador cómo interpretar su contenido. Para 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, ahorrando la necesidad de convertir desde alguna otra codificación en tiempo de ejecución. QStringView puede construirse fácil y eficientemente a partir de uno, por lo que pueden pasarse a funciones que acepten un argumento QStringView (o, como resultado, un QAnyStringView).

Los literales definidos por el usuario tienen la misma forma que los definidos por C++, pero añaden un sufijo después de las comillas de cierre. La codificación sigue determinada por el prefijo, pero el literal resultante se utiliza para construir un objeto de algún tipo definido por el usuario. Por tanto, Qt define esto para algunos de sus propios tipos de cadena: u"foo"_s 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 C++ plano "foo" se entenderá como UTF-8 y la conversión a QString y por lo tanto UTF-16 será costosa. Cuando tengas literales de cadena en ASCII plano, utiliza "foo"_L1 para interpretarlo como Latin-1, obteniendo los diversos beneficios descritos anteriormente.

Clases básicas de cadenas

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

Algunas de las entradas que faltan pueden sustituirse por tipos C++ incorporados y de biblioteca estándar: Una cadena propia codificada en Latin-1 o UTF-8 puede ser 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 matchers, QLatin1StringMatcher y QByteArrayMatcher. Los matchers también tienen versiones estáticas que se crean en tiempo de compilación, QStaticLatin1StringMatcher y QStaticByteArrayMatcher.

Además, cabe destacar que

• QStringLiteral es una macro idéntica a u"foo"_s y disponible sin StringLiterals Namespace. Es preferible utilizar la cadena literal moderna.
• QLatin1String es un sinónimo de QLatin1StringView y existe por compatibilidad con versiones anteriores. No es una cadena propia y podría eliminarse en futuras versiones.
• QAnyStringView proporciona una vista para una cadena con cualquiera de las tres codificaciones soportadas. La codificación se almacena junto con la referencia a los datos. Esta clase es muy adecuada para crear interfaces que tomen un amplio espectro de tipos de cadena y codificaciones. A diferencia de otras clases, no se realiza ningún procesamiento en QAnyStringView directamente. El procesamiento se realiza en QLatin1StringView, QUtf8StringView o QStringView en la codificación respectiva. Utilice QAnyStringView::visit() para hacer lo mismo en sus propias funciones que tomen esta clase como argumento.
• Un QLatin1StringView con caracteres no ASCII no es sencillo de construir en un archivo de código fuente codificado en UTF-8 y requiere un tratamiento especial; consulte la documentación de QLatin1StringView.
• QStringRef es una referencia a una parte de QString, disponible en el módulo Qt5Compat por compatibilidad con versiones anteriores. Debería sustituirse por QStringView.

Clases de alto nivel relacionadas con las cadenas

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

• QRegularExpression QRegularExpressionMatch y para trabajar con concordancia de patrones y expresiones regulares. QRegularExpressionMatchIterator
• QLocale para convertir números y datos a y desde cadenas de manera apropiada al idioma y cultura del usuario.
• QCollator y QCollatorSortKey para comparar cadenas con respecto al idioma, escritura o territorio del usuario.
• QTextBoundaryFinder para dividir el texto listo para su composición tipográfica de acuerdo con las normas Unicode.
• QStringBuilderuna clase interna que mejorará sustancialmente el rendimiento de las concatenaciones de cadenas con el operador +, consulte la documentación de QString.

Algunas clases son plantillas o tienen una API flexible y trabajan con varias clases de cadenas. Éstas son

• QTextStream para introducir cadenas en QIODevice, QByteArray o QString
• QStringTokenizer para dividir cadenas

¿Qué clase de cadena utilizar?

La guía general en el uso de clases string es

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

Qt proporciona muchas funcionalidades para evitar asignaciones de memoria. La mayoría de los contenedores Qt emplean la compartición implícita de sus datos. Para que la compartición implícita funcione, debe haber una cadena ininterrumpida de la misma clase - convertir de QString a QStringView y viceversa resultará en dos QStrings que no comparten sus datos. Por lo tanto, las funciones necesitan pasar sus datos como QString (tanto valores como referencias funcionan). Extraer partes de una cadena no es posible con la compartición implícita de datos. Para utilizar partes de una cadena más larga, hay que recurrir a las vistas de cadena, una forma explícita de compartir datos.

Las conversiones entre codificaciones pueden reducirse ciñéndose a una codificación determinada. Los datos recibidos, por ejemplo, en UTF-8, se almacenan y procesan mejor en UTF-8 si no es necesario conversar a ninguna 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 determinada codificación se comparan a menudo o se convierten a cualquier otra codificación puede ser beneficioso convertirlas y almacenarlas una vez. Algunas operaciones proporcionan muchas sobrecargas (o una sobrecarga QAnyStringView ) para tomar varios tipos de cadenas y codificaciones y deberían ser la segunda opción para optimizar el rendimiento, si utilizar la misma codificación no es factible. Las conversiones explícitas de codificación antes de llamar a una función deberían ser el último recurso cuando no haya otra opción disponible. Latin-1 es una codificación muy simple y las operaciones entre Latin-1 y cualquier otra codificación son casi tan eficientes como las operaciones entre la misma codificación.

Debe elegirse la codificación más eficiente (de más a menos eficiente Latin-1, UTF-8, UTF-16) cuando no haya otras restricciones que determinen la codificación. Para el tratamiento de errores y el registro QLatin1StringView suele ser suficiente. Las cadenas visibles para el usuario en Qt son siempre de tipo QString y como tales codificadas en UTF-16. Por lo tanto es más efectivo usar QStrings, QStringViews y QStringLiterals durante todo el tiempo de vida de una cadena visible para el usuario. La función QObject::tr() proporciona la codificación y el tipo correctos. QByteArray debe utilizarse si la codificación no juega ningún papel, por ejemplo para almacenar datos binarios, o si la codificación es desconocida.

Clase String para crear API

Variables miembro

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

Argumentos de función

Los argumentos de función deben ser vistas de cadena de una codificación adecuada en la mayoría de los casos. QAnyStringView puede utilizarse como parámetro para admitir más de una codificación y QAnyStringView::visit() puede utilizarse internamente para bifurcarse en funciones por codificación. Si la función se limita a una sola codificación, debe utilizarse QLatin1StringView, QUtf8StringView, QStringView o QByteArrayView.

Si la función guarda el argumento en una cadena propia (normalmente una función setter), es más eficiente utilizar la misma cadena propia como argumento de la función para hacer uso de la funcionalidad implícita de compartición de datos de Qt. La cadena propietaria puede pasarse como referencia a const. Sobrecargar funciones con múltiples tipos de cadena propios y no propios puede llevar a ambigüedad de sobrecarga y debería evitarse. Los tipos de cadena propietarios en Qt pueden convertirse automáticamente a su versión no propietaria o a QAnyStringView.

Valores de retorno

Las cadenas temporales deben devolverse como una cadena propia, normalmente QString. Si la cadena devuelta es conocida en tiempo de compilación, utilice u"foo"_s para construir la estructura QString en tiempo de compilación. Si se devuelven cadenas propias existentes (por ejemplo, QString) desde una función completa (por ejemplo, una función getter), lo más eficiente es devolverlas por referencia. También se pueden devolver por valor para permitir la devolución de un temporal en el futuro. El uso de la compartición implícita de Qt evita el impacto en el rendimiento de la asignación y la copia cuando se devuelve por valor.

Partes de cadenas existentes pueden ser devueltas eficientemente con una vista de cadena de la codificación apropiada, para un ejemplo ver QRegularExpressionMatch::capturedView() que devuelve un QStringView.

Clase String para utilizar la API

Para utilizar una API de Qt de forma eficiente debes intentar que los tipos de argumentos de las funciones coincidan. Si está limitado en su elección, Qt realizará varias conversiones: Las cadenas propietarias se convierten implícitamente en cadenas no propietarias, las cadenas no propietarias pueden crear sus contrapartes propietarias, véase por ejemplo QStringView::toString(). Las conversiones de codificación se realizan implícitamente en muchos casos, pero esto debería evitarse si es posible. Para evitar la conversión implícita accidental de UTF-8 puede activar la macro QT_NO_CAST_FROM_ASCII.

Si necesita ensamblar una cadena en tiempo de ejecución antes de pasarla a una función, necesitará una cadena propia y, por tanto, QString. Si el argumento de la función es QStringView o QAnyStringView se convertirá implícitamente.

Si la cadena se conoce en tiempo de compilación, hay margen para la optimización. Si la función acepta un QString, deberá crearlo con u"foo"_s o la macro QStringLiteral. Si la función espera un QStringView, es mejor construirlo con un literal de cadena UTF-16 ordinario u"foo", si se espera un QLatin1StringView, constrúyalo con "foo"_L1. Si puede elegir entre ambos, por ejemplo si la función espera QAnyStringView, utilice la codificación más estricta, normalmente Latin-1.

Lista de todas las clases relacionadas con las cadenas