并发过滤器和过滤器-Reduce

QtConcurrent::filter()、QtConcurrent::filtered() 和 QtConcurrent::filedReduced() 函数并行过滤一个序列中的项目，如QList 。QtConcurrent::filter() 就地修改序列，QtConcurrent::filtered() 返回包含过滤内容的新序列，QtConcurrent::filteredReduced() 返回单一结果。

这些函数是 Qt Concurrent框架的一部分。

上述每个函数都有一个阻塞变体，它返回最终结果而不是QFuture 。使用它们的方法与异步变体相同。

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

请注意，上述结果类型不是QFuture 对象，而是真正的结果类型（本例中为QStringList 和QSet<QString>）。

并发过滤器

QtConcurrent::filtered() 接收一个输入序列和一个过滤函数。然后，序列中的每个项都会调用该过滤函数，并返回一个包含过滤值的新序列。

过滤函数的形式必须是

bool function(const T &t);

T 必须与序列中存储的类型相匹配。如果项目应被保留，函数返回true ；如果应被丢弃，函数返回 false。

本例展示了如何从QStringList 中保留全小写字符串：

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

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

过滤器的结果可通过QFuture 获取。有关如何在应用程序中使用QFuture 的详细信息，请参阅QFuture 和QFutureWatcher 文档。

如果您想就地修改序列，请使用 QtConcurrent::filter()：

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

由于序列是就地修改的，QtConcurrent::filter() 不会通过QFuture 返回任何结果。不过，您仍然可以使用QFuture 和QFutureWatcher 来监控过滤器的状态。

并发过滤和延续

QtConcurrent::filtered() 调用的结果是一个包含多个结果的QFuture 。当将.then() 续存附加到这样的QFuture 时，请确保使用将QFuture 作为参数的续存，否则只会处理第一个结果：

autokeepPositive= [](intval) {returnval> 0; }；QList<int>inputs {-1, 1, 2, -3, 5};autobadFuture=QtConcurrent::filtered(inputs,keepPositive) .then([](intval) {                             qDebug() << val;
                         });autogoodFuture=QtConcurrent::filtered(inputs,keepPositive).then([](QFuture<int>f) {for(autor : f.results()) {                                  qDebug() << r;
                              } });

在本例中，badFuture 只打印一个结果，而goodFuture 则打印所有结果。

并发过滤-还原

QtConcurrent::filteredReduced() 类似于 QtConcurrent::filtered()，但不是返回包含过滤结果的序列，而是使用 reduce 函数将结果合并为一个值。

reduce 函数的形式必须是

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

T 是最终结果的类型，U 是被过滤项的类型。注意，不使用 reduce 函数的返回值和返回类型。

像这样调用 QtConcurrent::filteredReduced()：

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

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

对于过滤函数保留的每个结果，reduce 函数将被调用一次，并应将中间结果合并到结果变量中。QtConcurrent::filteredReduced() 保证每次只有一个线程调用 reduce，因此无需使用互斥来锁定结果变量。QtConcurrent::ReduceOptions 枚举提供了一种控制还原顺序的方法。

其他 API 功能

使用迭代器代替序列

上述每个函数都有一个使用迭代器范围而非序列的变体。使用方法与序列变体相同：

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

使用成员函数

QtConcurrent::filter()、QtConcurrent::filtered()和 QtConcurrent::filteredReduced() 接受指向成员函数的指针。成员函数类的类型必须与存储在序列中的类型相匹配：

// 仅保留具有 alpha 通道的图像QList<QImage>images= .....；QFuture<void>alphaImages=QtConcurrent::filter(images, &QImage::hasAlphaChannel);// 检索灰度图像QList<QImage>images= .....；QFuture<QImage>灰度图像=QtConcurrent::filtered(images, &QImage::isGrayscale);// 创建一个包含所有可打印字符的集合QList<QChar>字符= .....；QFuture<QSet<QChar>>set=QtConcurrent::filteredReduced(characters, qOverload<>(&QChar::isPrint)、                                                         qOverload<const QChar&>(&QSet<QChar>::insert));

注意qOverload 的使用。需要使用它来解决有多个重载的方法的歧义问题。

还请注意，在使用 QtConcurrent::filteredReduced() 时，您可以自由混合使用普通函数和成员函数：

// 可以使用 QtConcurrent::filteredReduced() 混合使用普通函数和成员函数// 创建一个包含所有小写字符串的字典extern boolallLowerCase(constQString&string)；QStringList字符串= .....；QFuture<QSet<QString>>lowerCase=QtConcurrent::filteredReduced(strings,allLowerCase、                                                                 qOverload<const QString&>(&QSet<QString>::insert));

// 创建一个包含所有灰度图像的拼贴画extern void  addToCollage(QImage &collage, const QImage &grayscaleImage)；QList<QImage>images= .....；QFuture<QImage>拼贴=QtConcurrent::filteredReduced(images, &QImage::isGrayscale,addToCollage);

使用函数对象

QtConcurrent::filter()、QtConcurrent::filtered()和 QtConcurrent::filteredReduced() 接受过滤函数的函数对象。这些函数对象可用于为函数调用添加状态：

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")));

还原函数也支持函数对象：

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

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

使用 Lambda 表达式

QtConcurrent::filter()、QtConcurrent::filtered() 和 QtConcurrent::filteredReduced() 接受用于过滤和还原函数的 lambda 表达式：

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

当使用 QtConcurrent::filteredReduced() 或 QtConcurrent::blockingFilteredReduced() 时，您可以自由混合使用普通函数、成员函数和 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
);

您还可以将 lambda 传递给 reduce 对象：

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;
    }
);

封装包含多个参数的函数

如果要使用包含多个参数的过滤器函数，可以使用 lambda 函数或std::bind() 将其转换为包含一个参数的函数。

例如，我们使用QString::contains()：

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

QString::contains() 包含 2 个参数（包括 "this "指针），不能直接与 QtConcurrent::filtered() 一起使用，因为 QtConcurrent::filtered() 期望使用一个包含一个参数的函数。要在 QtConcurrent::filtered() 中使用QString::contains() ，我们必须为regexp参数提供一个值：

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

并发 Map 和 Map-Reduce 并发运行

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