Cambios en Qt Core
Qt 6 son el resultado de un esfuerzo deliberado por hacer que el marco sea más eficiente y fácil de usar.
Intentamos mantener la compatibilidad binaria y de código fuente para todas las API públicas en cada versión. Sin embargo, algunos cambios eran inevitables en nuestro esfuerzo por hacer de Qt un marco de trabajo mejor.
En este tema resumimos esos cambios en Qt Core y ofrecemos orientación para gestionarlos.
Clases contenedoras
QHash, QMultiHash, QSet
Firma de qHash()
Para los tipos personalizados, QHash y QMultiHash dependen de que se proporcione una función ` custom qHash() function ` en el mismo espacio de nombres. En Qt 4 y Qt 5, el valor de retorno y el segundo argumento opcional de una función ` qHash ` eran de tipo ` uint`. En Qt 6, es ` size_t`.
Es decir, hay que cambiar
por
size_t qHash(MyType x, size_t seed);Esto permite que QHash, QMultiHash y QSet puedan contener más de 2^32 elementos en plataformas de 64 bits.
Estabilidad de las referencias
La implementación de QHash, QMultiHash y QSet en Qt 6 ha pasado de un enfoque basado en nodos a una tabla de búsqueda en dos etapas. Este diseño permite mantener muy reducida la sobrecarga de memoria de una instancia de hash, al tiempo que ofrece un buen rendimiento.
Un cambio de comportamiento a tener en cuenta es que la nueva implementación no proporcionará referencias estables a los elementos del hash cuando la tabla tenga que ampliarse o cuando se eliminen entradas. Las aplicaciones que dependan de dicha estabilidad podrían ahora experimentar un comportamiento indefinido.
Eliminación de QHash::insertMulti
En Qt 5, se podía utilizar QHash para crear hash multivalor mediante QHash::insertMulti, y QMultiHash derivaba de QHash.
En Qt 6, tanto los tipos como los casos de uso son distintos, por lo que se ha eliminado `QHash::insertMulti`.
QVector, QList
Antes de Qt 6, QVector y QList eran clases independientes. En Qt 6, se han unificado: la implementación de Qt 5 QList ha desaparecido y ambas clases utilizan en su lugar la implementación actualizada de QVector. QList es la clase con la implementación real y QVector es un alias (typedef) de QList.
QListLos métodos fromVector() y toVector() de ` QVector`, así como los métodos fromList() y toList() de ` `, ya no implican copia de datos en Qt 6. Ahora devuelven el objeto para el que se les ha llamado.
Cambios en la API
QListEl tipo «size» de (y, por lo tanto, de QVector) ha cambiado de int a qsizetype. Junto con el tipo «size», se han actualizado las firmas de todos los métodos relevantes para utilizar qsizetype. Esto permite que QList pueda contener más de 2^31 elementos en plataformas de 64 bits.
Al actualizar el código base a Qt 6, este cambio en la API probablemente provocaría advertencias del compilador sobre conversiones de tipos con restricción. Si tuviéramos el siguiente código de ejemplo:
void myFunction(QList<MyType> &data) {
int size = data.size();
// ...
const int pos = getInsertPosition(size);
data.insert(pos, MyType());
// ...
}habría que actualizarlo para utilizar qsizetype o la palabra clave `auto`:
void myFunction(QList<MyType> &data) {
auto size = data.size();
// ...
const auto pos = getInsertPosition(size);
data.insert(pos, MyType());
// ...
}Como alternativa, puedes utilizar la conversión de tipos y convertir todo a ` int ` o a ` qsizetype`.
Nota: Si quieres compilar tanto para Qt 5 como para Qt 6, la palabra clave `auto` es una buena solución para cubrir las diferencias de firma entre las versiones.
Distribución de la memoria
QList ha recibido varios cambios relacionados con la disposición de la memoria en Qt 6.
En Qt 5, ` sizeof(QList<T>) ` equivalía al tamaño de un puntero. Ahora, se ha eliminado la indirección adicional del puntero y los miembros de datos ` QList ` se almacenan directamente en el objeto. Por defecto, se espera que ` sizeof(QList<T>) ` sea igual al tamaño de 3 punteros.
Al mismo tiempo, también se ha actualizado la disposición de los elementos en la memoria. Ahora, ` QList ` siempre almacena sus elementos directamente en la región de memoria asignada, a diferencia de lo que ocurría en Qt 5, donde ciertos objetos se asignaban por separado en el montón y, en su lugar, se colocaban punteros a dichos objetos en ` QList `.
Ten en cuenta que esto último, en particular, afecta a los objetos de gran tamaño. Para obtener el mismo comportamiento que en Qt 5, puedes envolver tus objetos en punteros inteligentes y almacenar estos punteros inteligentes directamente en ` QList `. En este caso, el tipo de tu ` QList ` sería ` QList<MySmartPointer<MyLargeObject>> `, en lugar de ` QList<MyLargeObject> ` como en Qt 5.
Estabilidad de las referencias
Se han introducido varios cambios en la implementación de QVector/QList. El relacionado con QVector es: se ha optimizado la inserción al principio (de forma similar a QList en Qt 5). El relacionado con QList es: se ha simplificado la disposición de la memoria para los elementos.
Importante: Estos cambios afectan a la estabilidad de las referencias. En Qt 6, debes tener en cuenta que cualquier método que modifique el tamaño o la capacidad invalida todas las referencias, incluso cuando QList no se comparta implícitamente. Las excepciones a esta regla se documentan explícitamente.
Las aplicaciones que dependen de una cierta estabilidad de las referencias podrían presentar un comportamiento indefinido al actualizarse a Qt 6. Debes prestar especial atención a los casos en los que se utilizaron originalmente QVector o QList con una disposición de matriz no compatible con C.
Clases de vista en Qt6
Descripción general
Qt 6 incluye varias clases nuevas de « View ». Además de la ya existente « QStringView », ahora se suman « QByteArrayView », seguida de una versión especializada, « QUtf8StringView », y otra más universal, « QAnyStringView ».
Introducción a las clases de vista con el ejemplo de QStringView
La clase QStringView proporciona una vista unificada de las cadenas UTF-16 con un subconjunto de solo lectura de la API de QString. A diferencia de QString, que mantiene su propia copia de la cadena (posiblemente con recuento de referencias), QStringView proporciona una vista de una cadena que se almacena en otro lugar.
char hello[]{ "Hello." }; // narrow multi-byte string literal
QString str{hello}; // needs to make a copy of the string literal
QString strToStr(str); // atomic increment involved to not create a copy of hello again
// The above code can be re-written to avoid copying and atomic increment.
QStringView view{ u"Hello." }; // view to UTF-16 encoded string literal
QStringView viewToView{ view }; // view of the same UTF-16 encoded string literalLa cadena "Hello." está almacenada en el binario y no se asigna en tiempo de ejecución. view es solo una vista de la cadena "Hello.", por lo que no es necesario crear ninguna copia. Cuando copiamos un QStringView, el viewToView observa la misma cadena que observa el view del que se ha copiado. Esto significa que viewToView no necesita crear una copia ni realizar un incremento atómico. Son vistas de la cadena existente "Hello.".
Las vistas como argumento de función
Las vistas deben pasarse por valor, no por referencia a una constante.
void myfun1(QStringView sv); // preferred
void myfun2(const QStringView &sv); // compiles and works, but slowerFunciones de manipulación de vistas
QStringView admite funciones que nos permiten manipular la vista de la cadena. Esto nos permite modificar la vista sin crear una copia parcial de la cadena a la que se accede.
QString pineapple = "Pineapple";
QString pine = pineapple.left(4);
// The above code can be re-written to avoid creating a partial copy.
QStringView pineappleView{ pineapple };
QStringView pineView = pineappleView.left(4);Cadenas no terminadas en nulo y cadenas que contienen '\0'
QStringView admite tanto cadenas terminadas en nulo como cadenas no terminadas en nulo. La diferencia radica en la forma de inicializar el ` QStringView`:
QChar aToE[]{ 'a', 'b', 'c', 'd', 'e' };
QStringView nonNull{ aToE, std::size(aToE) }; // with length given
QStringView nonNull{ aToE }; // automatically determines the length
QChar fToJ[]{ 'f', 'g', 'h', '\0', 'j' };
// uses given length, doesn't search for '\0', so '\0' at position 3
// is considered to be a part of the string similarly to 'h' and 'j
QStringView nonNull{ fToJ, std::size(fToJ) };
QStringView part{ fToJ }; //stops on the first encounter of '\0'Modelo de propiedad de las vistas
Dado que los ` views ` no son propietarios de la memoria a la que hacen referencia, hay que asegurarse de que los datos a los que se hace referencia (por ejemplo, los que pertenecen a un ` QString`) perduren más que el ` view ` en todas las rutas de ejecución del código.
QStringView sayHello()
{
QString hello("Hello.");
return QStringView{ hello }; // hello gets out of scope and destroyed
}
void main()
{
QStringView hello{ sayHello() };
qDebug() << hello; // undefined behavior
}Al convertir un QStringView en un QString
QStringView no la convertirá, ni implícita ni explícitamente, en un ` QString`, pero puede crear una copia profunda de sus datos:
void print(const QString &s) { qDebug() << s; }
void main()
{
QStringView string{ u"string"};
// print(string); // invalid, no implicit conversion
// QString str{ string }; // invalid, no explicit conversion
print(string.toString());
QString str = string.toString(); // create QString from view
}Notas importantes
Al aprovechar las nuevas clases de vista, se puede lograr una mejora significativa del rendimiento en muchos casos de uso. Sin embargo, es importante saber que puede haber algunas salvedades. Por lo tanto, es importante recordar lo siguiente:
- Las vistas deben pasarse por valor, no por referencia a const.
- Crear una vista con una longitud negativa es un comportamiento indefinido.
- Hay que tener cuidado de garantizar que los datos a los que se hace referencia (por ejemplo, los que pertenecen a un ` QString`) perduren más que la vista en todas las rutas de código.
Clases relacionadas con cadenas
La clase QStringView
A partir de Qt6, se recomienda en general utilizar ` QStringView ` en lugar de ` QStringRef`. ` QStringView ` hace referencia a una porción contigua de una cadena UTF-16 de la que no es propietaria. Actúa como un tipo de interfaz para todo tipo de cadenas UTF-16, sin necesidad de construir primero un ` QString `. La clase ` QStringView ` expone casi todos los métodos de solo lectura de ` QString ` y de la clase ` QStringRef `, que ya existía anteriormente.
Nota: Hay que asegurarse de que los datos de cadena a los que se hace referencia (por ejemplo, los que pertenecen a un ` QString`) perduren más que el ` QStringView ` en todas las rutas de ejecución del código.
Nota: Si un QStringView envuelve a un QString, hay que tener cuidado, ya que, a diferencia de QStringRef, QStringView no actualizará el puntero de datos interno una vez que los datos de QString se reubiquen.
QString string = ...;
QStringView view{string};
// Appending something very long might cause a relocation and will
// ultimately result in a garbled QStringView.
string += ...;La clase QStringRef
En Qt6, QStringRef se eliminó de Qt Core. Para facilitar la adaptación de las aplicaciones existentes sin tener que modificar todo el código base, la clase QStringRef no desapareció por completo, sino que se trasladó al módulo Qt5Compat. Si deseas seguir utilizando QStringRef, consulta «Uso del módulo Qt5Compat».
Lamentablemente, algunos métodos expuestos por QString que devuelven un QStringRef no se han podido trasladar a Qt5Compat. Por lo tanto, puede que sea necesario realizar alguna adaptación manual. Si su código utiliza una o varias de las siguientes funciones, deberá adaptarlas para que utilicen QStringView o QStringTokenizer. También se recomienda utilizar QStringView::tokenize en lugar de QStringView::split para el código en el que el rendimiento es fundamental.
Cambia el código que utilice QStringRef:
QString string = ...;
QStringRef left = string.leftRef(n);
QStringRef mid = string.midRef(n);
QStringRef right = string.rightRef(n);
QString value = ...;
const QVector<QStringRef> refs = string.splitRef(' ');
if (refs.contains(value))
return true;por:
QString string = ...;
QStringView left = QStringView{string}.left(n);
QStringView mid = QStringView{string}.mid(n);
QStringView right = QStringView{string}.right(n);
QString value = ...;
const QList<QStringView> refs = QStringView{string}.split(u' ');
if (refs.contains(QStringView{value}))
return true;
// or
const auto refs = QStringView{string}.tokenize(u' ');
for (auto ref : refs) {
if (ref == value)
return true;
}QMutex y clases relacionadas
En Qt 6, QRecursiveMutex ya no hereda de QMutex. Este cambio se ha realizado para mejorar el rendimiento tanto de QMutex como de QRecursiveMutex.
Debido a estos cambios, se ha eliminado la enumeración QMutex::RecursionMode, y QMutexLocker es ahora una clase basada en plantillas que puede funcionar tanto con QMutex como con QRecursiveMutex.
QFuture y clases relacionadas
La clase QFuture
Para evitar un uso involuntario de ` QFuture`, se han introducido algunos cambios en la API de ` QFuture ` en Qt 6, lo que puede provocar rupturas de compatibilidad en el código fuente.
Conversiones implícitas entre QFuture y otros tipos
Se ha desactivado la conversión de QFuture<T> a T. El operador de conversión llamaba a QFuture::result(), lo que podía provocar un comportamiento indefinido si el usuario había movido los resultados de QFuture mediante QFuture::takeResult() antes de intentar realizar la conversión. Utiliza explícitamente los métodos QFuture::result() o QFuture::takeResult(), cuando necesites convertir QFuture<T> a T.
La conversión implícita de QFuture<T> a QFuture<void> también se ha desactivado. Si realmente deseas realizar la conversión, utiliza el constructor explícito QFuture<void>(const QFuture<T> &):
Operadores de igualdad
Se han eliminado los operadores de igualdad de ` QFuture `. Estos comparaban los punteros `d` subyacentes en lugar de comparar los resultados, lo cual no es lo que los usuarios podrían esperar. Si necesitas comparar objetos ` QFuture `, utiliza los métodos ` QFuture::result() ` o ` QFuture::takeResult() `. Por ejemplo:
QFuture<int> future1 = ...;
QFuture<int> future2 = ...;
if (future1.result() == future2.result())
// ...Cambios en el comportamiento de QFuture y QFutureWatcher
En Qt 6 se introdujeron algunas mejoras en QFuture y QFutureWatcher que provocaron los siguientes cambios de comportamiento:
- Tras pausar QFuture o QFutureWatcher (mediante la llamada a
pause()osetPaused(true)), QFutureWatcher no dejará de emitir inmediatamente las señales de progreso y de resultado listo. En el momento de la pausa, es posible que aún haya cálculos en curso que no puedan detenerse. Las señales correspondientes a dichos cálculos pueden seguir enviándose tras la pausa, en lugar de posponerse y notificarse únicamente tras la siguiente reanudación. Para recibir una notificación cuando la pausa entre realmente en vigor, se puede utilizar la señal QFutureWatcher::suspended(). Además, existen los nuevos métodosisSuspending()yisSuspended(), que permiten comprobar si el QFuture está en proceso de suspensión o si ya se encuentra en estado suspendido. Tenga en cuenta que, por motivos de coherencia, tanto para QFuture como para QFutureWatcher, las API relacionadas con la pausa han quedado obsoletas y han sido sustituidas por métodos similares que incluyen la palabra «suspend» en el nombre. - QFuture::waitForFinished() esperará ahora hasta que QFuture se encuentre realmente en estado «finished», en lugar de salir tan pronto como deje de estar en estado «running». Esto evita que
waitForFinished()salga inmediatamente si, en el momento de llamarlo, el «future» aún no se ha iniciado. Lo mismo se aplica a QFutureWatcher::waitForFinished(). Este cambio no afectará al comportamiento del código que utilizaba QFuture con QtConcurrent. Solo el código que lo utilizaba con el método no documentadoQFutureInterfacepodría verse afectado. - QFutureWatcher::isFinished() ahora refleja el estado de finalización de la QFuture en lugar de devolver «false» hasta que se haya emitido QFutureWatcher::finished().
La clase QPromise
En Qt 6, se debe utilizar la nueva clase QPromise en lugar de la interfaz no oficial QFutureInterface como contrapartida «setter» de QFuture.
Clases de E/S
La clase QProcess
En Qt 6, la sobrecarga de ` QProcess::start()` que interpreta una única cadena de comando dividiéndola en nombre del programa y argumentos pasa a llamarse ` QProcess::startCommand()`. Sin embargo, existe una sobrecarga de ` QProcess::start()` que admite una sola cadena, así como una de ` QStringList ` para los argumentos. Dado que el parámetro QStringList toma por defecto una lista vacía, el código existente que solo pase una cadena seguirá compilándose, pero no podrá ejecutar el proceso si se trata de una cadena de comando completa que incluya argumentos.
Qt 5.15 introdujo advertencias de obsolescencia para la sobrecarga correspondiente con el fin de facilitar la detección y actualización del código existente:
QProcess process;
// compiles with warnings in 5.15, compiles but fails with Qt 6
process.start("dir \"My Documents\"");
// works with both Qt 5 and Qt 6; also see QProcess::splitCommand()
process.start("dir", QStringList({"My Documents"});
// works with Qt 6
process.startCommand("dir \"My Documents\"");Se han eliminado `QProcess::pid()` y el tipo `Q_PID`; utilice en su lugar ` QProcess::processId()` para obtener el identificador nativo del proceso. Ya no se admite el código que utiliza las API nativas de Win32 para acceder a los datos de `Q_PID` como una estructura ` PROCESS_INFORMATION ` de Win32.
Sistema de metatipos
La clase QVariant
QVariant se ha reescrito para utilizar QMetaType en todas sus operaciones. Esto implica cambios de comportamiento en algunos métodos:
QVariant::isNull()ahora solo devuelve «true» si la estructura «QVariant» está vacía o contiene un «nullptr». En Qt 5, también devolvía «true» para las clases de «qtbase» que contaban con un método «isNull» propio, siempre que este devolviera «true». El código que se basa en el comportamiento anterior debe comprobar si el valor contenido devuelve isNull; sin embargo, es poco probable que dicho código se dé en la práctica, ya queisNull()rara vez es la propiedad que interesa (compáreseQString::isEmpty()/isNull()yQTime::isValid/isNull).QVariant::operator==En Qt 6 se utilizaQMetaType::equals. Por lo tanto, algunos tipos que carecen de un operador de igualdad adecuado (comoQPixmapoQIcon) nunca se considerarán iguales. Además, los números de coma flotante almacenados enQVariantya no se comparan conqFuzzyCompare, sino que se utilizan comparaciones exactas.
Por otra parte, se han eliminado QVariant::operator<, QVariant::operator<=, QVariant::operator> y QVariant::operator>=, ya que no siempre es posible ordenar diferentes variantes. Esto también significa que QVariant ya no se puede utilizar como clave en un QMap.
La clase QMetaType
En Qt 6, el registro de comparadores y de los operadores de streaming QDebug y QDataStream se realiza automáticamente. En consecuencia, QMetaType::registerEqualsComparator(), QMetaType::registerComparators(), qRegisterMetaTypeStreamOperators() y QMetaType::registerDebugStreamOperator() ya no existen. Las llamadas a estos métodos deben eliminarse al realizar la migración a Qt 6.
Registro de tipos
Los tipos utilizados en Q_PROPERTY tienen su metatipo almacenado en el archivo QMetaObject de la clase. Esto requiere que los tipos estén completos cuando moc los detecte, lo que puede provocar errores de compilación en código que funcionaba en Qt 5. Hay tres formas de solucionar este problema:
- Incluir el archivo de cabecera que define el tipo.
- En lugar de utilizar una instrucción «include», utiliza la macro `
Q_MOC_INCLUDE`. Esto resulta útil si incluir el archivo de cabecera provocaría una dependencia cíclica o si ralentizaría la compilación. - Si el archivo de cabecera está presente en el archivo cpp que implementa la clase, también es posible incluir allí el archivo generado por moc.
Clases de expresiones regulares
La clase QRegularExpression
En Qt 6, el tipo ` QRegExp ` se ha trasladado al módulo `Qt5Compat` y todas las API de Qt que lo utilizaban se han eliminado de los demás módulos. El código de cliente que lo utilizaba puede adaptarse para usar ` QRegularExpression ` en su lugar. Dado que ` QRegularExpression ` ya está presente en Qt 5, esto puede realizarse y probarse antes de la migración a Qt 6.
La clase ` QRegularExpression `, introducida en Qt 5, implementa expresiones regulares compatibles con Perl y supone una gran mejora con respecto a ` QRegExp ` en cuanto a las API ofrecidas, la sintaxis de patrones admitida y la velocidad de ejecución. La mayor diferencia es que ` QRegularExpression ` simplemente contiene una expresión regular y no se modifica cuando se solicita una coincidencia. En su lugar, se devuelve un objeto ` QRegularExpressionMatch ` para comprobar el resultado de la coincidencia y extraer la subcadena capturada. Lo mismo se aplica a la coincidencia global y a ` QRegularExpressionMatchIterator`.
A continuación se describen otras diferencias.
Nota: QRegularExpression no admite todas las características disponibles en las expresiones regulares compatibles con Perl. La más notable es el hecho de que no se admiten nombres duplicados para los grupos de captura, y su uso puede dar lugar a un comportamiento indefinido. Esto podría cambiar en una futura versión de Qt.
Sintaxis de patrones diferente
La adaptación de una expresión regular de QRegExp a QRegularExpression puede requerir cambios en el propio patrón.
En casos concretos, QRegExp era demasiado permisivo y aceptaba patrones que simplemente no son válidos al utilizar QRegularExpression. Estos son fáciles de detectar, ya que los objetos QRegularExpression creados con estos patrones no son válidos (véase QRegularExpression::isValid()).
En otros casos, un patrón portado de QRegExp a QRegularExpression puede alterar la semántica de forma silenciosa. Por lo tanto, es necesario revisar los patrones utilizados. Los casos más destacados de incompatibilidad silenciosa son:
- Se necesitan llaves para utilizar un escape hexadecimal como
\xHHHHcon más de dos dígitos. Un patrón como\x2022debe portarse a\x{2022}; de lo contrario, coincidirá con un espacio (0x20) seguido de la cadena"22". En general, se recomienda encarecidamente utilizar siempre llaves con el escape\x, independientemente del número de dígitos especificados. - Una cuantificación de 0 a n como
{,n}debe adaptarse a{0,n}para conservar la semántica. De lo contrario, un patrón como\d{,3}coincidiría con un dígito seguido de la cadena exacta"{,3}". - QRegExp Por defecto, realiza una coincidencia compatible con Unicode, mientras que QRegularExpression requiere una opción independiente; véase más abajo para obtener más detalles.
- c{.} en QRegExp coincide, por defecto, con todos los caracteres, incluido el carácter de salto de línea. QRegularExpression excluye el carácter de salto de línea por defecto. Para incluir el carácter de salto de línea, establezca la opción de patrón QRegularExpression::DotMatchesEverythingOption.
Para obtener una visión general de la sintaxis de expresiones regulares compatible con QRegularExpression, consulte la página de manual pcrepattern(3), que describe la sintaxis de patrones compatible con PCRE (la implementación de referencia de las expresiones regulares compatibles con Perl).
La adaptación desde QRegExp::exactMatch()
QRegExp::exactMatch() tenía dos funciones: realizaba una coincidencia exacta de una expresión regular con una cadena objeto e implementaba la coincidencia parcial.
Portabilidad desde la coincidencia exacta de QRegExp
La coincidencia exacta indica si la expresión regular coincide con toda la cadena objeto. Por ejemplo, las clases devuelven los siguientes resultados con la cadena objeto "abc123":
| QRegExp::exactMatch() | QRegularExpressionMatch::hasMatch() | |
|---|---|---|
"\\d+" | false | true |
"[a-z]+\\d+" | verdadero | verdadero |
La coincidencia exacta no se refleja en ` QRegularExpression`. Si quieres asegurarte de que la cadena de búsqueda coincida exactamente con la expresión regular, puedes envolver el patrón utilizando la función ` QRegularExpression::anchoredPattern()`:
QString p("a .*|pattern");
// re matches exactly the pattern string p
QRegularExpression re(QRegularExpression::anchoredPattern(p));Portabilidad desde la coincidencia parcial de QRegExp
Al utilizar ` QRegExp::exactMatch()`, si no se encuentra una coincidencia exacta, aún es posible averiguar qué parte de la cadena de búsqueda ha coincidido con la expresión regular llamando a ` QRegExp::matchedLength()`. Si la longitud devuelta es igual a la longitud de la cadena de búsqueda, se puede concluir que se ha encontrado una coincidencia parcial.
QRegularExpression admite la coincidencia parcial de forma explícita mediante el método correspondiente QRegularExpression::MatchType.
Coincidencia global
Debido a las limitaciones de la API de QRegExp, resultaba imposible implementar correctamente la coincidencia global (es decir, tal y como lo hace Perl). En concreto, los patrones que pueden coincidir con 0 caracteres (como "a*") plantean problemas.
QRegularExpression::globalMatch() implementa correctamente la coincidencia global de Perl, y el iterador devuelto puede utilizarse para examinar cada resultado.
Por ejemplo, si tienes un código como este:
QString subject("the quick fox");
int offset = 0;
QRegExp re("(\\w+)");
while ((offset = re.indexIn(subject, offset)) != -1) {
offset += re.matchedLength();
// ...
}Puedes reescribirlo así:
QString subject("the quick fox");
QRegularExpression re("(\\w+)");
QRegularExpressionMatchIterator i = re.globalMatch(subject);
while (i.hasNext()) {
QRegularExpressionMatch match = i.next();
// ...
}Compatibilidad con propiedades Unicode
Al utilizar QRegExp, las clases de caracteres como \w, \d, etc., coinciden con caracteres que tengan la propiedad Unicode correspondiente: por ejemplo, \d coincide con cualquier carácter que tenga la propiedad Unicode « Nd » (dígito decimal).
Esas clases de caracteres solo coinciden con caracteres ASCII de forma predeterminada cuando se utiliza QRegularExpression: por ejemplo, \d coincide exactamente con un carácter del rango ASCII 0-9. Es posible cambiar este comportamiento utilizando la opción de patrón QRegularExpression::UseUnicodePropertiesOption.
Coincidencia con comodines
No existe una forma directa de realizar coincidencias con comodines en QRegularExpression. Sin embargo, se proporciona el método QRegularExpression::wildcardToRegularExpression() para traducir patrones glob a una expresión regular compatible con Perl que se puede utilizar para ese fin.
Por ejemplo, si tienes un código como este:
Puedes reescribirlo como:
auto wildcard = QRegularExpression(QRegularExpression::wildcardToRegularExpression("*.txt"));Ten en cuenta, no obstante, que es posible que algunos patrones con comodines propios de los shells no se traduzcan tal y como esperas. El siguiente código de ejemplo dejará de funcionar sin avisar si se convierte simplemente utilizando la función mencionada anteriormente:
const QString fp1("C:/Users/dummy/files/content.txt");
const QString fp2("/home/dummy/files/content.txt");
QRegExp re1("*/files/*");
re1.setPatternSyntax(QRegExp::Wildcard);
re1.exactMatch(fp1); // returns true
re1.exactMatch(fp2); // returns true
// but converted with QRegularExpression::wildcardToRegularExpression()
QRegularExpression re2(QRegularExpression::wildcardToRegularExpression("*/files/*"));
re2.match(fp1).hasMatch(); // returns false
re2.match(fp2).hasMatch(); // returns falseEsto se debe a que, por defecto, la expresión regular devuelta por ` QRegularExpression::wildcardToRegularExpression()` está totalmente anclada. Para obtener una expresión regular que no esté anclada, pasa ` QRegularExpression::UnanchoredWildcardConversion ` como opción de conversión:
QRegularExpression re3(QRegularExpression::wildcardToRegularExpression(
"*/files/*", QRegularExpression::UnanchoredWildcardConversion));
re3.match(fp1).hasMatch(); // returns true
re3.match(fp2).hasMatch(); // returns trueCoincidencia mínima
QRegExp::setMinimal() implementaba la coincidencia mínima simplemente invirtiendo la avidez de los cuantificadores (QRegExp no admitía cuantificadores perezosos, como *?, +?, etc.). En cambio, QRegularExpression sí admite cuantificadores ávidos, perezosos y posesivos. La opción de patrón « QRegularExpression::InvertedGreedinessOption » puede resultar útil para emular los efectos de « QRegExp::setMinimal()»: si se habilita, invierte el grado de «greediness» de los cuantificadores (los «greedy» se convierten en «lazy» y viceversa).
Modos de careta
La opción de coincidencia « QRegularExpression::AnchorAtOffsetMatchOption » se puede utilizar para emular el comportamiento de « QRegExp::CaretAtOffset ». No hay equivalente para los demás modos de « QRegExp::CaretMode ».
La clase QRegExp
En Qt6, « QRegExp » se ha eliminado de « Qt Core ». Si tu aplicación no se puede portar por el momento, « QRegExp » sigue existiendo en Qt5Compat para que estos códigos sigan funcionando. Si deseas seguir utilizando « QRegExp », consulta «Uso del módulo Qt5Compat».
QEvent y sus subclases
La clase ` QEvent ` definía un constructor de copia y un operador de asignación, a pesar de ser una clase polimórfica. La copia de clases con métodos virtuales puede provocar «slicing» al asignar objetos de diferentes clases entre sí. Dado que la copia y la asignación suelen producirse de forma implícita, esto podría dar lugar a problemas difíciles de depurar.
En Qt 6, el constructor de copia y el operador de asignación de las subclases de ` QEvent ` se han marcado como «protected» para evitar la copia implícita. Si necesitas copiar eventos, utiliza el método ` clone `, que devolverá una copia del objeto ` QEvent ` asignada en el montón. Asegúrate de eliminar el clon, quizá utilizando `std::unique_ptr`, a menos que lo envíes (en cuyo caso Qt lo eliminará una vez que se haya entregado).
En tus subclases de ` QEvent `, sobrescribe `clone()` y declara el constructor de copia y el operador de asignación como protegidos e implementados por defecto de la siguiente manera:
class MyEvent : public QEvent
{
public:
// ...
MyEvent *clone() const override { return new MyEvent(*this); }
protected:
MyEvent(const MyEvent &other) = default;
MyEvent &operator=(const MyEvent &other) = default;
MyEvent(MyEvent &&) = delete;
MyEvent &operator=(MyEvent &&) = delete;
// member data
};Ten en cuenta que, si tu clase `MyEvent` asigna memoria (por ejemplo, mediante un patrón de «puntero a la implementación»), tendrás que implementar una semántica de copia personalizada.
Clases de serialización
En Qt 6, se eliminaron los métodos de « QJsonDocument » para la conversión hacia y desde el formato binario JSON heredado de Qt en favor del formato CBOR estandarizado. Los tipos JSON de Qt se pueden convertir a tipos CBOR de Qt, que a su vez se pueden serializar al formato binario CBOR y viceversa. Véanse, por ejemplo, QCborValue::fromJsonValue() y QCborValue::toJsonValue().
Si aún necesitas utilizar el formato binario JSON, puedes recurrir a los sustitutos que ofrece el módulo Qt5Compat. Se encuentran en el espacio de nombres QBinaryJson. Consulta «Uso del módulo Qt5Compat» para saber cómo utilizar el módulo en tu aplicación.
Otras clases
En Qt 5, QCoreApplication::quit() equivalía a llamar a QCoreApplication::exit(). Esto simplemente salía del bucle de eventos principal.
En Qt 6, el método intentará, en su lugar, cerrar todas las ventanas de nivel superior enviando un evento de cierre. Las ventanas pueden cancelar libremente el proceso de cierre ignorando el evento.
Llama a ` QCoreApplication::exit()` para mantener el comportamiento no condicional.
QLibraryInfo::location() y QLibraryInfo::Location han quedado obsoletas debido a una nomenclatura incoherente. Utiliza en su lugar la nueva API: QLibraryInfo::path() y QLibraryInfo::LibraryPath.
Qt State Machine El marco
Qt State Machine se ha trasladado al módulo Qt SCXML (que pronto pasará a llamarse Qt State Machine) y, por lo tanto, ya no forma parte de Qt Core. Había muy pocas dependencias cruzadas dentro de Qt Core, lo que finalmente llevó a tomar esta decisión.
Uso del módulo Qt5Compat
Para utilizar el módulo Qt5Compat, debes compilar con sus encabezados en tu ruta de inclusión y enlazar con su biblioteca. Si utilizas qmake, añade lo siguiente a tu archivo .pro:
QT += core5compatSi compilas tu aplicación o biblioteca con cmake, añade lo siguiente a tu archivo CMakeList.txt:
PUBLIC_LIBRARIES
Qt::Core5CompatQTextStream
Se ha eliminado QTextStream::setCodec(). Utiliza en su lugar QTextStream::setEncoding() con la nueva enumeración Encoding.
© 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.