Summing values in a vector using threads
Firstly, it's a good first attempt at writing some threaded code. The major sticking point is that you're passing in an int &amp; 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&lt;int&gt;::size_type;

int adder( const std::vector&lt;int&gt; &amp; v, size_type begin, size_type end)
{
    for( ; begin &lt; 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 &lt;typename Iterator&gt;
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 &lt;iterator&gt;):

template &lt;typename Iterator&gt;
std::iterator_traits&lt;Iterator&gt;::value_type 
adder(Iterator begin, Iterator end)
{
    std::iterator_traits&lt;Iterator&gt;::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 &lt;algorithm&gt;):

template &lt;typename Iterator&gt;
typename std::iterator_traits&lt;Iterator&gt;::value_type
adder(Iterator begin, Iterator end)
{
    using T = typename std::iterator_traits&lt;Iterator&gt;::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 &lt;future&gt;):

template &lt;typename Iterator&gt;
typename std::iterator_traits&lt;Iterator&gt;::value_type
parallel_sum(Iterator begin, Iterator end)
{
    using T = typename std::iterator_traits&lt;Iterator&gt;::value_type;
    auto midpoint = begin + std::distance(begin, end) / 2;
    std::future&lt;T&gt; f1 = std::async(std::launch::async, adder&lt;Iterator&gt;, begin, midpoint);
    std::future&lt;T&gt; f2 = std::async(std::launch::async, adder&lt;Iterator&gt;, midpoint, end);
    return f1.get() + f2.get();
}


We then use this as follows:

int main()
{
    std::vector&lt;int&gt; v;
    for(int i = 0; i &lt; 100000; ++i) {
        v.push_back(i);
    }
    int total = parallel_sum(v.begin(), v.end());
    std::cout &lt;&lt; total &lt;&lt; "\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.