Pointers in C

[Praveen]

Hi,

I came across a program as follows
main()
{
int x, y ;
int *p1 = &x;
int *p2 = &y;
printf("%d\n", p1-p2);
}

The output of the above program is 1.
Can some one explain me how it is 1.
Thanks in advance.

[Ian Collins]

Praveen wrote:

Hi,

I came across a program as follows
main()
{
int x, y ;
int *p1 = &x;
int *p2 = &y;
printf("%d\n", p1-p2);
}

The output of the above program is 1.
Can some one explain me how it is 1.

Because that's what your compiler gives as the answer, subtracting two
unrelated pointers is undefined behaviour.

--
Ian Collins.

[Raman]

On Feb 21, 11:18 am, Ian Collins <[e-mail] mwrote:

Praveen wrote:

Hi,

I came across a program as follows
main()
{
int x, y ;
int *p1 = &x;
int *p2 = &y;
printf("%d\n", p1-p2);
}

The output of the above program is 1.
Can some one explain me how it is 1.

>>>Because that's what your compiler gives as the answer, subtracting two
unrelated pointers is undefined behaviour.

Can Some onr tell why these are unrelated?

>
--
Ian Collins.

[Chris Dollin]

Raman wrote:

On Feb 21, 11:18 am, Ian Collins <[e-mail] mwrote:

>Praveen wrote:

Hi,

I came across a program as follows
main()
{
int x, y ;
int *p1 = &x;
int *p2 = &y;
printf("%d\n", p1-p2);
}

The output of the above program is 1.
Can some one explain me how it is 1.

>>>>Because that's what your compiler gives as the answer, subtracting two
>unrelate d pointers is undefined behaviour.

Can Some onr tell why these are unrelated?

They're not part of the same object [1]. (Stack frames are not objects,
even in implementations that have stack frames, from C's POV.)

[1] Which covers `malloc` results too.

--
Chris "electric hedgehog" Dollin
"Life is full of mysteries. Consider this one of them." Sinclair, /Babylon 5/

[Stuart]

"Raman" <ra***********@ gmail.comwrote in message
news:11******** **************@ j27g2000cwj.goo glegroups.com.. .

On Feb 21, 11:18 am, Ian Collins <[e-mail] mwrote:

<snip OP attribution>

>>I came across a program as follows
main()
{
int x, y ;
int *p1 = &x;
int *p2 = &y;
printf("%d\n", p1-p2);
}

The output of the above program is 1.
Can some one explain me how it is 1.

>Because that's what your compiler gives as the answer, subtracting two
unrelated pointers is undefined behaviour.

Can Some onr tell why these are unrelated?

To be related they must have some common reference point - the source of the
relationship. If there is no common reference point how can there be a
relationship? The language standard will define what types of relationship
exist between different components defined in a program text.

In what way do you believe the pointers are related? What makes you believe
this? Can you find a citation in the language standard that supports this
belief?

--
Stuart

[Keith Thompson]

"Raman" <ra***********@ gmail.comwrites :

On Feb 21, 11:18 am, Ian Collins <[e-mail] mwrote:

>Praveen wrote:

Hi,

I came across a program as follows
main()
{
int x, y ;
int *p1 = &x;
int *p2 = &y;
printf("%d\n", p1-p2);
}

The output of the above program is 1.
Can some one explain me how it is 1.

>>>>Because that's what your compiler gives as the answer, subtracting two
>unrelate d pointers is undefined behaviour.

Can Some onr tell why these are unrelated?

Because they point to distinct objects.

Here's what the standard says in the section on relational operators
(<, <=, >, >=) (C99 6.5.8p5):

When two pointers are compared, the result depends on the relative
locations in the address space of the objects pointed to. If two
pointers to object or incomplete types both point to the same
object, or both point one past the last element of the same array
object, they compare equal. If the objects pointed to are members
of the same aggregate object, pointers to structure members
declared later compare greater than pointers to members declared
earlier in the structure, and pointers to array elements with
larger subscript values compare greater than pointers to elements
of the same array with lower subscript values. All pointers to
members of the same union object compare equal. If the expression
P points to an element of an array object and the expression Q
points to the last element of the same array object, the pointer
expression Q+1 compares greater than P. In all other cases, the
behavior is undefined.

(A non-array object is treated as an array of one element.)

--
Keith Thompson (The_Other_Keit h) ks***@mib.org <http://www.ghoti.net/~kst>
San Diego Supercomputer Center <* <http://users.sdsc.edu/~kst>
We must do something. This is something. Therefore, we must do this.

[Richard Heathfield]

Praveen said:

Hi,

I came across a program as follows
main()
{
int x, y ;
int *p1 = &x;
int *p2 = &y;
printf("%d\n", p1-p2);
}

The output of the above program is 1.
Can some one explain me how it is 1.

Even if the pointer arithmetic were legal (which others have already
pointed out, so I won't belabour it here), the call to printf is not.
Whether the (undefined) result of your illegal pointer arithmetic is
reported correctly by printf is undefined, because you failed to
provide a valid function prototype within the current scope at the
point of call to a variable argument function.

Headers are not decorative. They matter. In future, if you call printf,
do this:

#include <stdio.h>

--
Richard Heathfield
"Usenet is a strange place" - dmr 29/7/1999
http://www.cpax.org.uk
email: rjh at the above domain, - www.

[rafalp]

Praveen wrote:

>
I came across a program as follows
main()
{
int x, y ;
int *p1 = &x;
int *p2 = &y;
printf("%d\n", p1-p2);
}

The output of the above program is 1.
Can some one explain me how it is 1.

Well, if you change the last line to

printf("%d\n", (char*)p1-(char*)p2);

you will get 4, ie sizeof(int), instead of 1. Is that what you expected?
In pointer arithmetic the distance between two pointers is measured in
number of object of pointer's type that would fit between the memory
locations pointed by the pointers. Thus with array

int a[10]

you can access the second element by a[1] or by *(a + 1). We add 1 to
the actual pointer but in fact compiler adds 4 or sizeof(int) to the
pointer.

Hope that helps.

[Richard Heathfield]

rafalp said:

<snip>

Well, if you change the last line to

printf("%d\n", (char*)p1-(char*)p2);

you will get 4, ie sizeof(int), instead of 1.

No, the behaviour will still be undefined, for two separate reasons.

--
Richard Heathfield
"Usenet is a strange place" - dmr 29/7/1999
http://www.cpax.org.uk
email: rjh at the above domain, - www.

[rafalp]

Richard Heathfield wrote:

rafalp said:

>Well, if you change the last line to

printf("%d\n ", (char*)p1-(char*)p2);

you will get 4, ie sizeof(int), instead of 1.

No, the behaviour will still be undefined, for two separate reasons.

You're right. I should have written "you will get value >= sizeof(int)"
instead.