Les changements apportés à Qt Concurrent

Qt 6 est le résultat d'un effort conscient pour rendre le cadre plus efficace et plus facile à utiliser.

Nous essayons de maintenir la compatibilité binaire et source pour toutes les API publiques dans chaque version. Mais certains changements étaient inévitables dans un effort pour faire de Qt un meilleur framework.

Dans cette rubrique, nous résumons ces changements dans Qt Concurrent, et fournissons des conseils pour les gérer.

QtConcurrent::run()

QtConcurrent::run() a été amélioré pour fonctionner avec un nombre variable d'arguments, les signatures sont donc modifiées en :

// run
template <typename T>
QFuture<T> run(Function &&f, Args &&...args)

// run with a QThreadPool argument
template <typename T>
QFuture<T> run(QThreadPool *pool, Function &&f, Args &&...args)

Comme effet secondaire, si f est un pointeur vers une fonction membre, le premier argument de args doit être l'objet pour lequel ce membre est défini (ou une référence, ou un pointeur vers lui). Ainsi, au lieu d'écrire :

QImage image = ...;
QFuture<void> future = QtConcurrent::run(&image, &QImage::invertPixels, QImage::InvertRgba);

il faut écrire :

QFuture<void> future = QtConcurrent::run(&QImage::invertPixels, &image, QImage::InvertRgba);

Un autre effet secondaire est que QtConcurrent::run() ne fonctionnera plus avec les fonctions surchargées. Par exemple, le code ci-dessous ne sera pas compilé :

void foo(int arg);
void foo(int arg1, int arg2);
...
QFuture<void> future = QtConcurrent::run(foo, 42);

La solution la plus simple est d'appeler la fonction surchargée via lambda :

QFuture<void> future = QtConcurrent::run([] { foo(42); });

Ou vous pouvez indiquer au compilateur quelle surcharge choisir en utilisant static_cast:

QFuture<void> future = QtConcurrent::run(static_cast<void(*)(int)>(foo), 42);

ou qOverload:

QFuture<void> future = QtConcurrent::run(qOverload<int>(foo), 42);

Les autres méthodes de QtConcurrent ne modifient pas le comportement et n'introduisent pas de rupture dans la compatibilité des sources.