acceptable fix for majority of signed/unsigned warnings?

Question

I myself am convinced that in a project I\'m working on signed integers are the best choice in the majority of cases, even though the value contained within can never be neg

Answer 1

Skip the index

The easiest approach is to sidestep the problem by using iterators, range-based for loops, or algorithms:

for (auto it = begin(v); it != end(v); ++it) { ... }
for (const auto &x : v) { ... }
std::for_each(v.begin(), v.end(), ...);

This is a nice solution if you don't actually need the index value. It also handles reverse loops easily.

Use an appropriate unsigned type

Another approach is to use the container's size type.

for (std::vector::size_type i = 0; i < v.size(); ++i) { ... }

You can also use std::size_t (from ). There are those who (correctly) point out that std::size_t may not be the same type as std::vector::size_type (though it usually is). You can, however, be assured that the container's size_type will fit in a std::size_t. So everything is fine, unless you use certain styles for reverse loops. My preferred style for a reverse loop is this:

for (std::size_t i = v.size(); i-- > 0; ) { ... }

With this style, you can safely use std::size_t, even if it's a larger type than std::vector::size_type. The style of reverse loops shown in some of the other answers require casting a -1 to exactly the right type and thus cannot use the easier-to-type std::size_t.

Use a signed type (carefully!)

If you really want to use a signed type (or if your style guide practically demands one), like int, then you can use this tiny function template that checks the underlying assumption in debug builds and makes the conversion explicit so that you don't get the compiler warning message:

#include 
#include 
#include 

template 
constexpr int size_as_int(const ContainerType &c) {
    const auto size = c.size();  // if no auto, use `typename ContainerType::size_type`
    assert(size <= static_cast(std::numeric_limits::max()));
    return static_cast(size);
}

Now you can write:

for (int i = 0; i < size_as_int(v); ++i) { ... }

Or reverse loops in the traditional manner:

for (int i = size_as_int(v) - 1; i >= 0; --i) { ... }

The size_as_int trick is only slightly more typing than the loops with the implicit conversions, you get the underlying assumption checked at runtime, you silence the compiler warning with the explicit cast, you get the same speed as non-debug builds because it will almost certainly be inlined, and the optimized object code shouldn't be any larger because the template doesn't do anything the compiler wasn't already doing implicitly.