C++ std:：accumulate并行实现中的编译错误

我编写了以下std:：acculate的并行实现，它给出了一个编译错误

错误：调用的对象类型“int”不是函数或函数指针 线程[i]=线程（批处理求和、块开始、块结束、参考（结果[i]）； 我该如何解决这个问题

#include <iostream>
#include <thread>
#include <algorithm>
#include <numeric>
#include <vector>

#define BATCH_SIZE 250

using namespace std;

template<typename Iterator, typename T>
void batch_sum(Iterator start, Iterator end, T &ref)
{
    ref = accumulate(start, end, 0);
}

template<typename Iterator, typename T>
T parallel_accumulate(Iterator start, Iterator end, T ref)
{
    unsigned input_size = distance(start, end);
    unsigned num_threads = input_size / BATCH_SIZE;
    unsigned hardware_threads = thread:: hardware_concurrency();
    num_threads = min(hardware_threads == 0 ? 2: hardware_threads, num_threads);
    vector<T> results(num_threads);

    vector<thread> threads(num_threads - 1);

    Iterator block_start;

    for(unsigned i = 0; i < num_threads - 1; ++i)
    {
        Iterator block_end = block_start;
        advance(block_end, BATCH_SIZE);
        threads[i] = thread(batch_sum<Iterator, T>, block_start, block_end, ref(results[i]));
        block_start = block_end;
    }

    results[num_threads - 1] = accumulate(block_start, end, 0);

    for_each(threads.begin(), threads.end(), mem_fn(&std:: thread:: join));

    return accumulate(results.begin(), results.end(), 0);
}

int main()
{
    vector<int> vec(28000, 0);
    cout << parallel_accumulate(begin(vec), end(vec), 0);
    return 0;
}

#包括
#包括
#包括
#包括
#包括
#定义批量大小250
使用名称空间std；
模板
无效批处理总和（迭代器开始、迭代器结束、T&ref）
{
ref=累计（开始、结束、0）；
}
模板
T并行_累加（迭代器开始、迭代器结束、T ref）
{
无符号输入大小=距离（起点、终点）；
unsigned num\u threads=输入大小/批大小；
未签名硬件\u线程=线程：：硬件\u并发（）；
num_threads=min（硬件线程==0？2：硬件线程，num_threads）；
向量结果（num_线程）；
向量线程（num_线程-1）；
迭代器块启动；
for（无符号i=0；i在
ref（结果[i]）
中，ref的预期值是否为0？在
ref（结果[i]）中
您可能打算使用
std:：ref
，但实际上您正试图使用局部变量
T ref
，这当然毫无意义。要么在函数调用中限定名称，要么重命名参数。这并不能解决问题，但
迭代器block_start；
会创建一个单一迭代器，即itera不引用任何范围的tor。随后的
迭代器block\u end=block\u start；
复制该迭代器，因此
block\u end
也是单数。