Fractional knapsack in C++11
Return or Output

I feel like FillKnapsack should either (a) simply tell you the max value or (b) give you the items that it used. Right now, you're returning (a) and logging, incompletely, (b). (Incomplete because if you use a fractional amount of an item, that's not indicated).

I suggest you pick one or the other. If the former, basically just drop the couts. If the latter, you'll want to return something like a:

std::vector&lt;std::pair&lt;Item, double&gt;&gt;


or:

struct ItemWithFraction {
    Item item;
    double fraction;
};
std::vector&lt;ItemWithFraction&gt;


Avoid single-letter variables

What is c? What is v? 

Move the break into the branch

We have two cases per item: either we can fit the whole item and have room to spare, or we can't. If we can't, then we break. So that can become:

for (const auto&amp; item : Items) {
    if (capacity + item.size &lt; MaxCap) {
        value += item.value;
        capacity += item.size;
    }
    else {
        // last little bit left
        value += (MaxCap - capacity) / item.size * item.value;
        break;
    }
}
return value;


Don't need to assign capacity in the else case either. 

Take items by copy

The idea of the algorithm suggests that given this set of items, find me a value. It doesn't suggest to me that you should reorder the items I pass in just because that happens to make it easier to solve the problem. To avoid being destructive, I'd write the signature as:

uint32_t FillKnapsack(std::vector&lt;Item&gt; Items, const uint32_t MaxCap)


If the user doesn't care, they can always move() the items in and avoid the copy. 

Naming

Typically, UpperCase naming are used for classes (e.g. Item). Functions and variables are typically either camelCase (with the first letter lower) or snake_case. So I'd prefer

fillKnapsack(std::vector&lt;Item&gt; items, const uint32_t maxCapacity);


and 

fill_knapsack(std::vector&lt;Item&gt; items, const uint32_t max_capacity);


to what you have.