Thread: Why does C allow the following construction

Here's a better question: What reason would you have for intentionally running off the end of your array?


Quzah.

No, I didn't say find some stupid way to do it. I said why on earth would you want to?


Quzah.

Originally Posted by cdalten

Okay, I guess I'm just not seeing why advancing the pointer one past the array is legal. I don't understand the reasoning behind this. The only part I understand is that allowing the pointer to advance any arbritrary number of points past the end of the array leads to undefined behavior.

It is just how the memory works and C not checking what you do.
Let us assume you have 2 arrays which are stored in the memory right next to each other.
The 1st is 8 characters long, the second one is 3 characters long.
So if you would move beyond the first array it would end up in the second one.

It is not a rule that the compiler allows this.
Although it just depens from the situation.
In your case I guess it is because you declared the pointer after you declared the variable so that when you go out of bounds the pointer just points to itself, which might perhaps explain why you can only move 1 space out of bounds.
(Just a guess it could turn out to be all wrong, because this depends, yet again from the situation/compiler,...)
It could go quite nasty if the memory next to the first array would be like in use by another program or something like that.

Whenever such a thing happens I get a Fatal exception or a General Processor fault.

There are 'some' reasons why you could do this but only if you are damn sure everything lies next to each other.
One example:
Reading all elements of a multidimensional array or matrix.
If the arrays are stored next to each other then you can easily read all the elements in the array starting from the primary element.
E.G:
matrix a=[[10,2][3,12]] (Sorry for non C syntaxis here)(It is because of my mathematical backround I still think in matrixes instead of multidimensional arrays)
After storing this in an array and allocating in the memory and if the elements are next to each other you could use your construction to for example get the sum of all the elements.
=>10, move forward, 2, move forward, ...


But this is not a healthy thing to do.

Originally Posted by cdalten

Why does C allow a pointer to advance just one beyond the end of the array

I think it is to allow this idiom.

Code:

#include <stdio.h>

int main(void)
{
   int *ptr, array[] = {1,2,3,4,5};
   size_t i;
   for ( i = 0; i < sizeof array / sizeof *array; ++i )
   {
      printf("array[%lu] = %d\n", (long unsigned)i, array[i]);
   }
   for ( ptr = array; ptr < array + sizeof array / sizeof *array; ++ptr )
   {
      printf("*ptr = %d\n", *ptr);
   }
   /* rather than requiring */
   for ( ptr = array; ptr <= array + sizeof array / sizeof *array - 1; ++ptr )
   {
      printf("*ptr = %d\n", *ptr);
   }
   return 0;
}

The expression array + sizeof array / sizeof *array is one element beyond the array bounds.

>Why does C allow a pointer to advance just one beyond the end of the array
C requires that arrays have a "past the end" element so that you can use its address as a sentinel:

Code:

int a[10];
int *p = a;

while ( p < &a[10] )
  ++p;

However, you're not allowed to go further than that, and you're not allowed to dereference the "past the end" element. If you do either, the behavior is undefined.

However, you're not allowed to go further than that

Why not? As long as you don't dereference the past-the-end element you should be fine. Right? (Not that you'd want to.)

Code:

#include <stdio.h>
#include <conio.h>

int main(void)
{
   int arr[2];
   int *p = arr;
   
   while(1)
   {
     getch();
     printf("%lu %d\n",++p,*p);
   }
   
	return 0;
}

My DevC++ compiler allows me to move very far.
Even p = arr + 100; won't crash the application.

"The behavior is undefined": we all know what that means. It works until your customers try to use it.

[edit]
getch() is a non-standard function. If you must use it, then include <conio.h>.
[/edit]