Firstly, it's a good first attempt at writing some threaded code. The major sticking point is that you're passing in an int & and returning void. Of course, std::thread will just run some code and won't return you a result. However, within the C++11 threading library, there are a number of things you can use that will allow you to return results, instead of having to use std::ref and reference parameters.

Before tackling that, let's look at the adder function itself. I'm going to go through a sequence of improvements that can be made to it. Firstly, you should try and use the correct type to index into a std::vector:

using size_type = std::vector<int>::size_type; int adder( const std::vector<int> & v, size_type begin, size_type end) { for( ; begin < end; ++begin ) { result = result + v.at( begin ); } } 

This is ok, but it could be a lot more generic: What if the values aren't stored in a std::vector? Instead, template this so that it can use anything that supports an iterator concept:

template <typename Iterator> int adder(Iterator begin, Iterator end) { int result = 0; for(auto it = begin; it != end; ++it) { result += *it; } return result; } 

Ok, getting there, but we can still improve this quite a bit: what if we want to sum any kind of numeric type? (Note this will require an #include <iterator>):

template <typename Iterator> std::iterator_traits<Iterator>::value_type adder(Iterator begin, Iterator end) { std::iterator_traits<Iterator>::value_type result; for(auto it = begin; it != end; ++it) { result += *it; } return result; } 

Ok, so we're not locked into a vector or an int type anymore. However, this pattern of summing up a bunch of values is really common, and there is library functionality that takes care of it for us: std::accumulate (note that this needs an #include <algorithm>):

template <typename Iterator> typename std::iterator_traits<Iterator>::value_type adder(Iterator begin, Iterator end) { using T = typename std::iterator_traits<Iterator>::value_type; return std::accumulate(begin, end, T()); } 

Now for the threading part.

The C++11 threading library has a really handy function called std::async. This allows you to run some piece of code in a thread, and retrieve a result from it. It will give you back what is known as a std::future (note that this needs an #include <future>):

template <typename Iterator> typename std::iterator_traits<Iterator>::value_type parallel_sum(Iterator begin, Iterator end) { using T = typename std::iterator_traits<Iterator>::value_type; auto midpoint = begin + std::distance(begin, end) / 2; std::future<T> f1 = std::async(std::launch_async, adder<Iterator>, begin, midpoint); std::future<T> f2 = std::async(std::launch_async, adder<Iterator>, midpoint + 1, end); f1.wait(); f2.wait(); return f1.get() + f2.get(); } 

We then use this as follows:

int main() { std::vector<int> v; for(int i = 0; i < 100000; ++i) { v.push_back(i); } int total = parallel_sum(v.begin(), v.end()); std::cout << total << "\n"; } 

There's probably too much to absorb here in one go, but I'll break down the main points:

• Try and make your functions work with the facilities provided by the standard library. Iterators permeate the container/algorithm side of it - if you can, try and work with iterators instead of directly with containers.
• Look for functionality in the standard library that can help you with common tasks, such as std::accumulate.
• With threading, if you want to get results back, prefer to use std::async instead of passing parameters by reference to store results.