For Loop Exit Condition (size_t vs. int)

Question

When I put the following in my program:

for (size_t i = VectorOfStructs.size()-1; i > 0; i--)

It works correctly but does "i" will never equal 0. So, I cannot access the first element (VectorOfStructs[0]).

If I change it to:

for (size_t i = VectorOfStructs.size()-1; i > -1; i--)

The program doesn't even enter the for loop! But, if I change it to the following:

for (int i = VectorOfStructs.size()-1; i > -1; i--)

It works exactly as I want it to (Iterates through all the elements).

So, my questions are:

(A) Why does the 2nd code snippet fail to execute?

(B) Why does the 3rd code snippet execute accordingly while the 2nd doesn't?

Any insight would be greatly appreciated!

size_t is an unsigned type, it is never larger than `(size_t)-1`. Most compilers generate a warning for this kind of code, you'll want to turn that on. — Hans Passant, Jul 27 '15 at 17:24
Perhaps better: `for (auto iter = VectorOfStructs.rbegin(); iter != VectorOfStructs.rend(); ++iter) { /* use *iter */ }` — aschepler, Jul 27 '15 at 17:27
If you want to iterate backwards, you should check for `i-- > 0` in the second part of the `for` loop and remove the third part of the for loop — KABoissonneault, Jul 27 '15 at 17:32

Kerrek SB · Answer 1 · 2015-07-27T17:50:01.497

4

All loops go forward, even the ones that go backwards.

What you want is either this:

for (std::size_t i = 0, e = VectorOfStructs.size(); i != e; ++i)
{
    std::size_t const ri = e - i - 1;

    // use "VectorOfStructs[ri]"
}

Or better:

for (auto rit = VectorOfStructs.rbegin(); rit != VectorOfStructs.rend(); ++rit)
{
    // use "*rit"
}

(Your second snippet fails because i is unsigned, so -1 is converted to the same type as i and becomes the maximal representable value, so the comparison is always true. By contrast, i is signed in the third snippet.)

edited Jul 27 '15 at 17:50

answered Jul 27 '15 at 17:35

Kerrek SB

464,522
92
875
1,084

Do you have a link for the "use()" function? I have never heard of that and a search turns up nothing. – Donald Jul 27 '15 at 17:49
@Donald: That's just a placeholder for your code! – Kerrek SB Jul 27 '15 at 17:49
I do not know how to use "*rit". If I do: int Counter=*rit; It gives me "error: no sutiable conversion function from "VectorOfStructs" to "int" exists" – Donald Jul 27 '15 at 18:17
@Donald: Iterators give you access to the vector elements, not the vector subscripts. – Kerrek SB Jul 27 '15 at 18:28

umläute · Accepted Answer · 2015-07-28T08:34:54.163

3

The second example uses size_t as type for i, which is an unsigned type, thus it can never have negative values; this also means that it cannot be properly compared with -1

But (int)-1 is bit-represented as 0xFFFFFFFF, which represents a rather large number (2^32-1) for size_t. i>0xFFFFFFFF can never be true, since 0xFFFFFFF is the largest value a size_t can ever hold.

The 3rd example uses signed int (which allows for negative numbers and therefore the test succeeds).

This one should work:

for (size_t i = VectorOfStructs.size(); i-- > 0;) {
  use(VectorOfStructs[i]);
}

edited Jul 28 '15 at 08:34

answered Jul 27 '15 at 17:23

umläute

28,885
9
68
122

Yeah, use the "--> operator" (see the related stackoverflow question) instead – KABoissonneault Jul 27 '15 at 17:30
@BenjaminLindley :facepalm: /me won't use *canonical* again... – umläute Jul 27 '15 at 17:36
@KABoissonneault hey, I already had fixed that before your comment... – umläute Jul 27 '15 at 17:42

score 3 · Answer 3 · answered Jul 27 '15 at 17:26

3

In second one you comparing variable 'i' with -1 , and here it is of type size_t and size can not be in negative so it fails.

In third one , 'i' is integer type and integer has range from -32568 to +32567 (for int=2 byte in a system)

Overall size_t variable can not have negative values because a physical memory will have its existence in the system

answered Jul 27 '15 at 17:26

Bhavesh Kumar

116
1
9

though `int` usually has 32bit == 4byte – umläute Jul 27 '15 at 17:28
earlier machines uses 2byte to store Integer variable but now machines store it in 2byte/4byte depending upon the **Architecture of System** – Bhavesh Kumar Jul 27 '15 at 17:30
sure; it's just *very uncommon* these days; – umläute Jul 27 '15 at 17:41
btw, could you elaborate on how *non-physical memory* would allow for negative sizes? – umläute Jul 27 '15 at 17:43
there does not exist any _non-physical_ memory , as if you think that about virtual memory then it also have some _physical_ existence – Bhavesh Kumar Jul 27 '15 at 17:47

score 2 · Answer 4 · answered Jul 27 '15 at 17:24

2

Why does the 2nd code snippet fail to execute?

size_t is unsigned, so it is by definition never negative. So your loop condition is always true. The variable "wraps around" to the maximum value.

answered Jul 27 '15 at 17:24

rlbond

65,341
56
178
228

score 1 · Answer 5 · answered Jul 27 '15 at 17:24

1

size_t is an unsigned type so -1 is the maximum value size_t can take. In the second snippet size_t can't be greater than this maximum value so the loop isn't entered.

On the other hand, int is a signed type so the comparison to -1 is as you expect.

answered Jul 27 '15 at 17:24

Null

1,950
9
30
33

score 0 · Answer 6 · answered Jul 27 '15 at 17:36

Int and size_t are both integer types but int can hold negatives as well as positives. int ranges from -2^31 -1 to 2^31 -1 while size_t ranges from 0 to 2^32 -1

Now, when you write something like int a = -1 it is indeed -1 but when you do so with size_t you get the max int 2^32 -1

So in the 2nd snippet no size_t value will ever exceed -1 as it really 2^32 -1

In the 3rd snippet the type compared is int and when int is compared to -1 it sees it as -1 so it executes the way you planned

score 0 · Answer 7 · answered Jul 27 '15 at 17:37

When the compiler sees i > -1 and notices that the subexpressions i and -1 have different types, it converts them both to a common type. If the two types (std::size_t and int) have the same number of bits, which appears to be the case for your compiler, the common type is the unsigned one (std::size_t). So the expression turns out to be equivalent to i > (std::size_t)-1. But of course (std::size_t)-1 is the maximum possible value of a size_t, so the comparison is always false.

Most compilers have a warning about a comparison that is always true or always false for reasons like this.

score 0 · Answer 8 · 2015-07-27T18:05:55.083

Whenever you compare 'signed' and 'unsigned' the 'signed' values are converted to 'unsigned', first. That covers (#1) and (#2), having a problems with 'unsigned(0-1)' and 'some unsigned' > 'unsigned max'.

However, making it work by forcing a 'signed'/'signed' compare (#3), you loose 1/2 of the 'unsigned' range.

You may do:

for(size_t n = vector.size(); n; /* no -- here */ ) {
   --n;
   // vector[n];
}

Note: unsigned(-1) is on many systems the biggest unsigned integer value.

For Loop Exit Condition (size_t vs. int)

8 Answers8

Linked