Pointer increment

[braton]

Hello

I'm wondering about the following thing:

Let's define variable and set a pointer to points to it:

int a = 0;
int * p_a = &a;

Now, according to C99, clause 6.5.6.7 I can treat pointer to "a"
like a pointer to the first element of the array of length 1 for
the purpose of additive operators. So after:

p_a++;

my pointer points to one past last element of the array and
it seems to be ok. But what about the following next statement:

++p_a;

I found the following part of clause 8 a bit unclear:

"If both the pointer operand and the result point to elements of the
same
array object, or one past the last element of the array object, the
evaluation
shall not produce an overflow; otherwise, the behavior is undefined."

The question is:
the behaviour is undefined when I just incremented pointer more than
one past last
element of the array or it is undefined when I dereference such
incremented pointer.
If the former could somebody give an example of architecture where
just setting
pointer that way produces some sort of exception.

Thanks for your help

[santosh]

br****@gmail.com wrote:

Hello

I'm wondering about the following thing:

Let's define variable and set a pointer to points to it:

int a = 0;
int * p_a = &a;

Now, according to C99, clause 6.5.6.7 I can treat pointer to "a"
like a pointer to the first element of the array of length 1 for
the purpose of additive operators. So after:

p_a++;

my pointer points to one past last element of the array and
it seems to be ok. But what about the following next statement:

++p_a;

Identical.

>
I found the following part of clause 8 a bit unclear:

"If both the pointer operand and the result point to elements of the
same
array object, or one past the last element of the array object, the
evaluation
shall not produce an overflow; otherwise, the behavior is undefined."

The question is:
the behaviour is undefined when I just incremented pointer more than
one past last
element of the array or it is undefined when I dereference such
incremented pointer.
If the former could somebody give an example of architecture where
just setting
pointer that way produces some sort of exception.

Thanks for your help

It is allowed to point to one past an object, but not to actually access
that location. No such guarantees for one before the object.

[Ben Bacarisse]

br****@gmail.com writes:

Let's define variable and set a pointer to points to it:

int a = 0;
int * p_a = &a;

Now, according to C99, clause 6.5.6.7 I can treat pointer to "a"
like a pointer to the first element of the array of length 1 for
the purpose of additive operators. So after:

p_a++;

my pointer points to one past last element of the array and
it seems to be ok. But what about the following next statement:

++p_a;

I found the following part of clause 8 a bit unclear:

"If both the pointer operand and the result point to elements of the
same
array object, or one past the last element of the array object, the
evaluation
shall not produce an overflow; otherwise, the behavior is
undefined."

You'd have to say what you find unclear. To me it is clear. The fist
pointer increment is OK, the second is not.

The question is:
the behaviour is undefined when I just incremented pointer more than
one past last
element of the array or it is undefined when I dereference such
incremented pointer.

The pointer arithmetic itself gives the UB. You get UB if you
de-reference the "one past the end" pointer, but just computing the
next pointer is not permitted.

If the former could somebody give an example of architecture where
just setting
pointer that way produces some sort of exception.

A system where every object is in its own bounded memory segment would
be one. I think some ICL machines could do this. Cambridge
University made a machine with hardware security where every object
was in hardware-checked segment and the pointer had access permission
information in it.

Of course, standards are there so your code will also work on machines
not yet designed.

--
Ben.