Iteration over std::vector: unsigned vs signed index variable

In C , there are two common approaches to iterate over a vector: using iterators or using indices. When using indices, it is important to consider the type of the index variable.

Using iterators

Iterators are a convenient way to iterate over a container. They provide a uniform interface for different types of containers, and they allow for efficient traversal of the elements. The following code demonstrates how to iterate over a vector using iterators:

for (auto it = v.begin(); it != v.end();   it) {
  // do something with *it
}

Using indices

When iterating over a vector using indices, it is important to use a signed index variable. This is because vectors are indexed from 0 to size() - 1, and a signed variable can represent this range more naturally. In the following example, a signed int is used to index the vector:

for (int i = 0; i 
Why using an unsigned index variable can be dangerous
Using an unsigned index variable can be dangerous because it can lead to undefined behavior if the index exceeds the size of the vector. This is because an unsigned variable wraps around when it reaches its maximum value, and this can cause the index to be negative, which is not a valid index for a vector.
In the following example, an unsigned int is used to index the vector, and if the size of the vector is greater than the maximum value of an unsigned int, the index will wrap around and become negative, resulting in undefined behavior:
for (unsigned int i = 0; i 
Conclusion
When iterating over a vector, it is always preferable to use a signed index variable. This is because it ensures that the index will always be within the valid range for the vector, and avoids the potential for undefined behavior.