Finding indices of numbers that sum to a target
Not quite right

First off, you're checking every cross pair of indices against each other. But that means that findTwoSum({1, 3, 4}, 6) will succeed, even though there is no pair of elements that sum to 6 - because you count the 3 twice. You need: "any two distinct elements".

Iterating over vectors

list is a confusing name for a vector. increment is a poor variable name for this - since it's not incrementing anything, it's just another index, so you really should use i and j instead. Also you don't need at() - that member function does range checking. But your indices will all definitely be in range, so you could simply write:

for (size_t i = 0; i &lt; v.size(); ++i) {
    for (size_t j = i+1; j &lt; v.size(); ++j) { // correcting initial bug
        if (v[i] + v[j] == target) {
            return std::make_pair(i, j);
        }
    }
}
return std::make_pair(-1, -1);


Failure case

Rather than using sentinel values, I prefer to use something like Boost.Optional to indicate failure, so that:

boost::optional&lt;std::pair&lt;int, int&gt;&gt; findTwoSum(const std::vector&lt;int&gt;&amp;, int target);


Classes

Why is findTwoSum a static member function? Just make it a free function. There's no reason for a class. You could instead make TwoSum a namespace but I don't see the point of that either. 

The Algorithm

You are checking every pair of indices - that's \$O(n^2)\$. We can do way better. Consider that once we have our first index - there is one unique element that we need to find to see if we have a success case: target - v[i]. 

We could simply throw all of our indices into a map:

std::unordered_map&lt;int, size_t&gt; indices;
for (size_t i = 0; i &lt; v.size(); ++i) {
    indices.insert(std::make_pair(v[i], i));
}


And then simply search if target - v[i] is in indices for each such i:

for (size_t i = 0; i &lt; v.size(); ++i) {
    auto j = indices.find(target - v[i]);
    if (j != indices.end()) {
        return std::make_pair(i, j-&gt;second);
    }
}


This will be \$O(n)\$ to create the hashtable, and then another \$O(n)\$ to do all the searching... for a grand total of \$O(n)\$.