C++11: Thread pool for successive input reduction - multithreading

Question

Consider a container of type T elements, e.g. std::vector<T> input, and an excessively time-consuming function T f(const T&, const T&). I wish to apply f on input until one single element remains - in parallel.
I am new to C++ so I adapted an existing implementation for a Thread pool pattern in C++11 to my needs, in particular this example.
Code for discussion:
#include <thread>
#include <iostream>
#include <algorithm>
#include <vector>
#include <queue>
#include <memory>
#include <future>
#include <functional>
#include <stdexcept>
#include "ThreadPool.h"
template<class T>
T ParallelReduction(ThreadPool& pool, const std::vector<T>& input, const std::function<T(T,T)>& func)
{
std::queue<std::future<T>> futureResults;
std::for_each(input.begin(), input.end(), [&futureResults](T e)
{
// T -> future<T>
futureResults.push(std::async([e]{return e;}));
});
for (;;)
{
if (futureResults.size() > 1)
{
// Get two "old" partial results, forward them to func(T,T)
T a = futureResults.front().get();
futureResults.pop();
T b = futureResults.front().get();
futureResults.pop();
futureResults.push(pool.enqueue([a, b, func]{return func(a,b);}));
}
else
{
// all input and partial result elements have been processed once, return the final result
return futureResults.front().get();
}
}
}
int main(int argc, char *argv[])
{
ThreadPool pool(4);
std::vector<int> input(12);
int n = 0;
std::generate(input.begin(), input.end(), [&n]{ return ++n; });
auto sum = ParallelReduction<int>(pool, input, [](int a, int b){return a + b;});
std::cout << sum << "\n";
auto fibonacci = ParallelReduction<int>(pool, input, [](int a, int b){return a * b;});
std::cout << fibonacci << "\n";
return 0;
}
My questions:
Is it possible to implement this without introducing futureResults, i.e. a solution that works "inline" on std::vector<T>& input?
If not, can we optimize the way we assign values T to std::future<T> in the first part?
Is it more efficient to forward std::future<T> to our function func instead of T, i.e. let the child thread wait and access the value of a and b and not the main thread?
The parts inside the loop look awful - any ideas?
Where can I optimize the code?