CODEWITHSUNDEEP
c++
Marlon
Marlon

Reputation: 20312

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

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?

Upvotes: 5

Views: 473

Answers (7)

MSalters
MSalters

Reputation: 180050

Quite a few architectures that would be affected by this solve the problem by reserving offset 0xFFFFFFFF (and a bit more) for the OS.

Upvotes: 0

phunctor
phunctor

Reputation: 609

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.

Upvotes: 0

Karoly Horvath
Karoly Horvath

Reputation: 96286

  • 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.

Upvotes: 1

librik
librik

Reputation: 3788

I think there is a good argument for suggesting that a conformant C implementation cannot allow an array to end at (e.g.) 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.

Upvotes: 1

Shahbaz
Shahbaz

Reputation: 47583

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.

Upvotes: 3

Greg Hewgill
Greg Hewgill

Reputation: 994251

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.

Upvotes: 9

pmr
pmr

Reputation: 59841

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.

Upvotes: 0

Related Questions