Problem - Kevin Tafuro

which the records begin. Generally, programmers will make sure the item index is
not too high, but they may not realize that the index might be too low!
In addition, it is good to remember that array accesses are rewritten as pointer arithmetic.
For example, arr[x] can index memory before the start of your array if x is
less than 0 once converted to a signed integer.
Size mismatches
You may also encounter problems when an integer type of one size gets converted to
an integer type of another size. For example, suppose that you store an unsigned 64bit
quantity in x, then pass x to an operation that takes an unsigned 32-bit quantity.
In C, the upper 32 bits will get truncated. Therefore, if you need to check for overflow,
you had better do it before the cast happens!
Conversely, when there is an implicit coercion from a small value to a large value,
remember that the sign bit will probably extend out, which may not be intended.
That is, when C converts a signed value to a different-sized signed value, it does not
simply start treating the same bits as a signed value. When growing a number, C will
make sure that it retains the same value it once had, even if the binary representation
is different. When shrinking the value, C may truncate, but even if it does, the sign
will be the same as it was before truncation, which may result in an unexpected
binary representation.
For example, you might have a string declared as a char *, then want to treat the
bytes as integers. Consider the following code:
int main(int argc, char *argv[ ]) {
int x = 0;
if (argc > 1) x += argv[1][0];
printf("%d\n", x);
}
If argv[1][0] happens to be 0xFF, x will end up –1 instead of 255! Even if you
declare x to be an unsigned int, you will still end up with x being 0xFFFFFFFF
instead of the desired 0xFF, because C converts size before sign. That is, a char will
get sign-extended into an int before being coerced into an unsigned int.
Wrap-around
A very similar problem (with the same remediation strategy as those described in previous
subsections) occurs when a variable wraps around. For example, when you
add 1 to the maximum unsigned value, you will get zero. When you add 1 to the
maximum signed value, you will get the minimum possible signed value.
This problem often crops up when using a high-precision clock. For example, some
people use a 32-bit real-time clock, then check to see if one event occurs before
another by testing the clock. Of course, if the clock rolls over (a millisecond clock
Preventing Integer Coercion and Wrap-Around Problems | 91
This is the Title of the Book, eMatter Edition
Copyright © 2007 O’Reilly & Associates, Inc. All rights reserved.