QtConcurrent::mappedReduced without mapped

Question

Consider the following code (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;
});

As you can see the first lambda expression passed to QtConcurrent::mappedReduced looks unnecessary. That's why I want to find something like QtConcurrent::reduced in Qt 6. Or how can I refactor this code to use only 1 lambda expression?

Answer 1

You can use std::accumulate.

The goal of QtConcurrent mappedReduce is the apply an operation on all the items of container in a concurrent fashion and once done do the reduction.

In your case there's nothing to be done but the sum of the items so there's no need for mappedReduce.

Update:

Based on your comments here is an example using a custom class with the operator+ overloaded using a QList as container.

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

Here is a version with 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;
}

Update 2:

Based on @IlBeldus suggestion, here is the version were you use std::accumulate with 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;
}