How do I take the address of one past the end of an array if the last address is 0xFFFFFFFF?

Question

If it is legal to take the address one past the end of an array, how would I do this if the last element of array's address is 0xFFFFFFFF ?

How would this code work:

for (vector<char>::iterator it = vector_.begin(), it != vector_.end(); ++it)
{
}

Edit:

I read here that it is legal before making this question: May I take the address of the one-past-the-end element of an array?

Answer 1

If this situation is a problem for a particular architecture (it may or may not be), then the compiler and runtime can be expected to arrange that allocated arrays never end at 0xFFFFFFFF . If they were to fail to do this, and something breaks when an array does end there, then they would not conform to the C++ standard.

Answer 2

Accessing out of the array boundaries is undefined behavior. You shouldn't be surprised if a demon flies out of your nose (or something like that)

What might actually happen would be an overflow in the address which could lead to you reading address zero and hence segmentation fault.

If you are always within the array range, and you do the last ++it which goes out of the array and you compare it against _vector.end() , then you are not really accessing anything and there should not be a problem.

Answer 3

• It's not legal to access one past the end of an array
• that code doesn't actually access that address.
• and you will never get an address like that on a real system for you objects.

Answer 4

I think there is a good argument for suggesting that a conformant C implementation cannot allow an array to end at (eg) 0xFFFFFFFF.

Let p be a pointer to one-element-off-the-end-of-the-array: if buffer is declared as char buffer[BUFFSIZE] , then p = buffer+BUFFSIZE , or p = &buffer[BUFFSIZE] . (The latter means the same thing, and its validity was made explicit in the C99 standard document.)

We then expect the ordinary rules of pointer comparison to work, since the initialization of p was an ordinary bit of pointer arithmetic. (You cannot compare arbitrary pointers in standard C, but you can compare them if they are both based in a single array, memory buffer, or struct.) But if buffer ended at 0xFFFFFFFF, then p would be 0x00000000, and we would have the unlikely situation that p < buffer !

This would break a lot of existing code which assumes that, in valid pointer arithmetic done relative to an array base, the intuitive address-ordering property holds.

Answer 5

The difference is between dereferencing that element and taking its address. In your example the element past the end wont be dereferenced and so it is a valid. Although this was not really clear in the early days of C++ it is clear now. Also the value you pass to subscript does not really matter.

Answer 6

Sometimes the best thing you can do about corner cases is forbid them. I saw this class of problem with some bit field extraction instructions of the NS32032 in which the hardware would load 32 bits starting at the byte address and extract from that datum. So even single-bit fields anywhere in the last 3 bytes of mapped memory would fail. The solution was to never allow the last 4 bytes of memory to be available for allocation.

Answer 7

相当多的受此影响的架构通过为OS保留偏移量0xFFFFFFFF （以及更多）来解决问题。