Modifications apportées à Qt Concurrent

Qt 6 sont le résultat d’un effort délibéré visant à rendre le framework plus efficace et plus facile à utiliser.

Nous nous efforçons de maintenir la compatibilité binaire et source pour toutes les API publiques à chaque version. Cependant, certaines modifications étaient inévitables afin d’améliorer le framework Qt.

Dans cette rubrique, nous résumons ces modifications dans Qt Concurrent et fournissons des conseils pour les prendre en compte.

QtConcurrent::run()

La fonction QtConcurrent::run() a été améliorée pour prendre en charge un nombre variable d’arguments ; ses signatures ont donc été modifiées comme suit :

// 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)

En conséquence, si ` f ` est un pointeur vers une fonction membre, le premier argument de ` args ` doit être l’objet pour lequel cette fonction membre est définie (ou une référence, ou un pointeur vers celui-ci). 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 se compilera pas :

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

La solution la plus simple consiste à appeler la fonction surchargée via un lambda :

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

static_castVous pouvez également indiquer au compilateur quelle surcharge choisir en utilisant une expression lambda :

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 présentent aucun changement de comportement et n’introduisent pas de rupture de compatibilité avec le code source.