En esta página

Filtro y filtro-reducción concurrentes

Las funciones QtConcurrent::filter(), QtConcurrent::filtered() y QtConcurrent::filteredReduced() filtran elementos de una secuencia, como una QList, en paralelo. QtConcurrent::filter() modifica una secuencia in situ, QtConcurrent::filtered() devuelve una nueva secuencia que contiene el contenido filtrado y QtConcurrent::filteredReduced() devuelve un único resultado.

Estas funciones forman parte del Qt Concurrent marco de trabajo.

Cada una de las funciones anteriores tiene una variante bloqueante que devuelve el resultado final en lugar de un ` QFuture`. Se utilizan de la misma manera que las variantes asíncronas.

QStringList strings = ...;

// each call blocks until the entire operation is finished
QStringList lowerCaseStrings = QtConcurrent::blockingFiltered(strings, allLowerCase);

QtConcurrent::blockingFilter(strings, allLowerCase);

QSet<QString> dictionary = QtConcurrent::blockingFilteredReduced(strings, allLowerCase, addToDictionary);

Ten en cuenta que los tipos de resultado anteriores no son objetos ` QFuture `, sino tipos de resultado reales (en este caso, ` QStringList ` y ` QSet<QString>`).

Optimizar inclusiones

Si se incluye el encabezado <QtConcurrent>, se incluirán los módulos completos Qt Concurrent y Qt Core, lo que puede aumentar los tiempos de compilación y el tamaño de los binarios. Para utilizar las funciones QtConcurrent::filter(), QtConcurrent::filtered() y QtConcurrent::filteredReduced(), se puede incluir un encabezado más específico:

#include <QtConcurrentFilter>

Filtro concurrente

QtConcurrent::filtered() toma una secuencia de entrada y una función de filtro. A continuación, esta función de filtro se invoca para cada elemento de la secuencia y se devuelve una nueva secuencia que contiene los valores filtrados.

La función de filtrado debe tener la siguiente forma:

bool function(const T &t);

T debe coincidir con el tipo almacenado en la secuencia. La función devuelve ` true ` si el elemento debe conservarse, y `false` si debe descartarse.

Este ejemplo muestra cómo conservar las cadenas que están todas en minúsculas de un ` QStringList`:

bool allLowerCase(const QString &string)
{
    return string.lowered() == string;
}

QStringList strings = ...;
QFuture<QString> lowerCaseStrings = QtConcurrent::filtered(strings, allLowerCase);

Los resultados del filtro están disponibles a través de ` QFuture`. Consulta la documentación de ` QFuture ` y ` QFutureWatcher ` para obtener más información sobre cómo utilizar ` QFuture ` en tus aplicaciones.

Si desea modificar una secuencia in situ, utilice QtConcurrent::filter():

QStringList strings = ...;
QFuture<void> future = QtConcurrent::filter(strings, allLowerCase);

Dado que la secuencia se modifica in situ, QtConcurrent::filter() no devuelve ningún resultado a través de ` QFuture`. No obstante, puede seguir utilizando ` QFuture ` y ` QFutureWatcher ` para supervisar el estado del filtro.

Filtrado concurrente y continuaciones

El resultado de la llamada a QtConcurrent::filtered() es un QFuture que contiene varios resultados. Al asociar una continuación de tipo .then() a dicho QFuture, asegúrate de utilizar una continuación que tome QFuture como parámetro; de lo contrario, solo se procesará el primer resultado:

auto keepPositive = [](int val) {
    return val > 0;
};

QList<int> inputs {-1, 1, 2,-3, 5 };
auto badFuture = QtConcurrent::filtered(inputs, keepPositive)
                         .then([](int val) {
                             qDebug() << val;
                         });

auto goodFuture = QtConcurrent::filtered(inputs, keepPositive)
                          .then([](QFuture<int> f) {
                              for (auto r : f.results()) {
                                  qDebug() << r;
                              }
                          });

En este ejemplo, badFuture solo mostrará un único resultado, mientras que goodFuture mostrará todos los resultados.

Filtro-reducción concurrente

QtConcurrent::filteredReduced() es similar a QtConcurrent::filtered(), pero en lugar de devolver una secuencia con los resultados filtrados, los resultados se combinan en un único valor mediante una función de reducción.

La función de reducción debe tener la siguiente forma:

V function(T &result, const U &intermediate)

T es el tipo del resultado final; U es el tipo de los elementos que se filtran. Ten en cuenta que no se utilizan el valor de retorno ni el tipo de retorno de la función de reducción.

Llama a QtConcurrent::filteredReduced() de la siguiente manera:

void addToDictionary(QSet<QString> &dictionary, const QString &string)
{
    dictionary.insert(string);
}

QStringList strings = ...;
QFuture<QSet<QString>> dictionary = QtConcurrent::filteredReduced(strings, allLowerCase, addToDictionary);

La función `reduce` se llamará una vez por cada resultado conservado por la función de filtrado, y debe fusionar el resultado intermedio en la variable `result`. `QtConcurrent::filteredReduced()` garantiza que solo un hilo llamará a `reduce` a la vez, por lo que no es necesario utilizar un mutex para bloquear la variable `result`. La enumeración ` QtConcurrent::ReduceOptions ` permite controlar el orden en el que se realiza la reducción.

Características adicionales de la API

Uso de iteradores en lugar de secuencias

Cada una de las funciones anteriores tiene una variante que admite un rango de iteradores en lugar de una secuencia. Se utilizan de la misma forma que las variantes de secuencia:

QStringList strings = ...;
QFuture<QString> lowerCaseStrings = QtConcurrent::filtered(strings.constBegin(), strings.constEnd(), allLowerCase);

// filter in-place only works on non-const iterators
QFuture<void> future = QtConcurrent::filter(strings.begin(), strings.end(), allLowerCase);

QFuture<QSet<QString>> dictionary = QtConcurrent::filteredReduced(strings.constBegin(), strings.constEnd(), allLowerCase, addToDictionary);

Uso de funciones miembro

QtConcurrent::filter(), QtConcurrent::filtered() y QtConcurrent::filteredReduced() aceptan punteros a funciones miembro. El tipo de clase de la función miembro debe coincidir con el tipo almacenado en la secuencia:

// conservar solo las imágenes con canal alfa
QList<QImage> images =...;
QFuture<void> alphaImages = QtConcurrent::filter(images,&QImage::hasAlphaChannel);

// recuperar imágenes en escala de grises
QList<QImage> imágenes =...;
QFuture<QImage> imágenesEnEscalaDeGrises = QtConcurrent::filtered(imágenes,&QImage::isGrayscale);

// crear un conjunto de todos los caracteres imprimibles
QList<QChar> caracteres =...;
QFuture<QSet<QChar>> conjunto = QtConcurrent::filteredReduced(caracteres, qOverload<>(&QChar::isPrint),
                                                         qOverload<const QChar&>(&QSet<QChar>::insert));

Fíjate en el uso de « qOverload ». Es necesario para resolver la ambigüedad en los métodos que tienen varias sobrecargas.

Ten en cuenta también que, al utilizar QtConcurrent::filteredReduced(), puedes combinar libremente el uso de funciones normales y funciones miembro:

// Se pueden mezclar funciones normales y funciones miembro con QtConcurrent::filteredReduced()

// Crear un diccionario con todas las cadenas en minúsculas
extern bool allLowerCase(const QString&string);
QStringList strings =...;
QFuture<QSet<QString>> lowerCase = QtConcurrent::filteredReduced(strings, allLowerCase,
                                                                 qOverload<const QString&>(&QSet<QString>::insert));

// Crear un collage con todas las imágenes en escala de grises
extern void addToCollage(QImage &collage, const QImage &grayscaleImage);
QList<QImage> imágenes =...;
QFuture<QImage> collage = QtConcurrent::filteredReduced(imágenes,&QImage::isGrayscale, addToCollage);

Uso de objetos de función

QtConcurrent::filter(), QtConcurrent::filtered() y QtConcurrent::filteredReduced() admiten objetos de función como función de filtrado. Estos objetos de función se pueden utilizar para añadir estado a una llamada a función:

struct StartsWith
{
    StartsWith(const QString &string)
    : m_string(string) { }

    bool operator()(const QString &testString)
    {
        return testString.startsWith(m_string);
    }

    QString m_string;
};

QList<QString> strings = ...;
QFuture<QString> fooString = QtConcurrent::filtered(strings, StartsWith(QLatin1String("Foo")));

Los objetos de función también son compatibles con la función reduce:

struct StringTransform
{
    void operator()(QString &result, const QString &value);
};

QFuture<QString> fooString =
        QtConcurrent::filteredReduced(strings, StartsWith(QLatin1String("Foo")), StringTransform());

Uso de expresiones lambda

QtConcurrent::filter(), QtConcurrent::filtered() y QtConcurrent::filteredReduced() admiten expresiones lambda para las funciones filter y reduce:

// keep only even integers
QList<int> list { 1, 2, 3, 4 };
QtConcurrent::blockingFilter(list, [](int n) { return (n & 1) == 0; });

// retrieve only even integers
QList<int> list2 { 1, 2, 3, 4 };
QFuture<int> future = QtConcurrent::filtered(list2, [](int x) {
    return (x & 1) == 0;
});
QList<int> results = future.results();

// add up all even integers
QList<int> list3 { 1, 2, 3, 4 };
QFuture<int> sum = QtConcurrent::filteredReduced(list3,
    [](int x) {
        return (x & 1) == 0;
    },
    [](int &sum, int x) {
        sum += x;
    }
);

Al utilizar QtConcurrent::filteredReduced() o QtConcurrent::blockingFilteredReduced(), puedes combinar libremente el uso de funciones normales, funciones de miembro y expresiones lambda.

void intSumReduce(int &sum, int x)
{
    sum += x;
}

QList<int> list { 1, 2, 3, 4 };
QFuture<int> sum = QtConcurrent::filteredReduced(list,
    [] (int x) {
        return (x & 1) == 0;
    },
    intSumReduce
);

También se puede pasar una expresión lambda como objeto de reducción:

bool keepEvenIntegers(int x)
{
    return (x & 1) == 0;
}

QList<int> list { 1, 2, 3, 4 };
QFuture<int> sum = QtConcurrent::filteredReduced(list,
    keepEvenIntegers,
    [](int &sum, int x) {
        sum += x;
    }
);

Envolver funciones que admiten varios argumentos

Si quieres utilizar una función de filtro que admita más de un argumento, puedes utilizar una función lambda o un std::bind() o para transformarla en una función que admita un solo argumento.

A modo de ejemplo, utilizaremos ` QString::contains()`:

bool QString::contains(const QRegularExpression &regexp) const;

QString::contains() toma 2 argumentos (incluido el puntero «this») y no se puede utilizar directamente con QtConcurrent::filtered(), ya que QtConcurrent::filtered() espera una función que tome un solo argumento. Para utilizar QString::contains() con QtConcurrent::filtered(), debemos proporcionar un valor para el argumento regexp:

QStringList strings = ...;
QFuture<QString> future = QtConcurrent::filtered(list, [](const QString &str) {
    return str.contains(QRegularExpression("^\\S+$")); // matches strings without whitespace
});

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