0

考虑以下代码（Qt 6.0.3，C++17）：

const QVector<int> arr = {1, 2, 3, 4, 5};
auto future = QtConcurrent::mappedReduced<int>(arr, [](auto item) {
    return item;
}, [](int& result, auto item) {
    result += item;
});

如您所见，传递给的第一个 lambda 表达式QtConcurrent::mappedReduced看起来没有必要。这就是为什么我想QtConcurrent::reduced在 Qt 6 中找到类似的东西。或者我如何重构这段代码以仅使用 1 个 lambda 表达式？

4

1 回答 1

1

您可以使用std::accumulate。

QtConcurrent mappedReduce 的目标是以并发方式对容器的所有项目应用操作，一旦完成就进行归约。

在你的情况下，除了项目的总和之外，没有什么可做的，所以不需要 mappedReduce。

更新：

根据您的评论，这里是一个使用自定义类的示例，该类operator+使用 QList 作为容器重载。

class MyClass
{
public:
    MyClass(int x=0, int y=0):
       _x(x),
       _y(y)
    {}

    int x() const { return _x; }
    int y() const { return _y; }

public:
    int _x;
    int _y;
};

MyClass operator+(const MyClass& left, const MyClass &right)
{
    MyClass m;
    m._x = left._x + right._x;
    m._y = left._y + right._y;
    return m;
}

这是一个版本std::accumulate

#include <QVector>
#include <QtDebug>
#include <numeric>

int main(int argc, char **argv)
{
    Q_UNUSED(argc);
    Q_UNUSED(argv);

    QVector<MyClass> myClassList = {MyClass(12, 42), MyClass(23, 53)};
    MyClass result = std::accumulate(myClassList.constBegin(), myClassList.constEnd(), MyClass());
    qDebug() << result.x() << result.y();
    return 0;
}

更新 2：

根据@IlBeldus 的建议，这是您使用的std::accumulate版本QtConcurrent::run

#include <QtDebug>
#include <QVector>
#include <QtConcurrent>
#include <numeric>

MyClass myAccumulate(const QVector<MyClass> &input)
{
    return std::accumulate(input.constBegin(), input.constEnd(), MyClass());
}

int main(int argc, char **argv)
{
    Q_UNUSED(argc);
    Q_UNUSED(argv);

    QVector<MyClass> myClassList = {MyClass(12, 42), MyClass(23, 53)};
    QFuture<MyClass> future = QtConcurrent::run(myAccumulate, myClassList);
    result = future.result();
    qDebug() << result.x() << result.y();
    return 0;
}
于 2021-05-23T18:22:56.907 回答