指针类型转换

Question

int main()
{
int *p,*q;
p=(int *)1000;
q=(int *)2000;
printf("%d:%d:%d",q,p,(q-p));
}

output

2000:1000:250

1.I cannot understand p=(int *)1000; line, does this mean that p is pointing to 1000 address location? what if I do *p=22 does this value is stored at 1000 address and overwrite the existing value? If it overwrites the value, what if another program is working with 1000 address space?

1. how qp=250 ?

EDIT: I tried printf("%u:%u:%u",q,p,(qp)); the output is the same

int main()
{
int *p;
int i=5;
p=&i;
printf("%u:%d",p,i);
return 0;
}

the output

3214158860:5

1. does this mean the addresses used by compiler are integers? there is no difference between normal integers and address integers?

Answer 1

does this mean that p is pointing to 1000 address location?

Yes.

what if I do *p=22

It's invoking undefined behavior - your program will most likely crash with a segfault.

Note that in modern OSes, addresses are virtual - you can't overwrite an other process' adress space like this, but you can attempt writing to an invalid memory location in your own process' address space.

how qp=250?

Because pointer arithmetic works like this (in order to be compatible with array indexing). The difference of two pointers is the difference of their value divided by sizeof(*ptr) . Similarly, adding n to a pointer ptr of type T results in a numeric value ptr + n * sizeof(T) .

Read this on pointers.

does this mean the addresses used by compiler are integers?

That "used by compiler" part is not even necessary. Addresses are integers, it's just an abstraction in C that we have nice pointers to ease our life. If you were coding in assembly, you would just treat them as unsigned integers.

By the way, writing

printf("%u:%d", p, i);

is also undefined behavior - the %u format specifier expects an unsigned int , and not a pointer. To print a pointer, use %p :

printf("%p:%d", (void *)p, i);

Answer 2

Yes, with *p=22 you write to 1000 address.

qp is 250 because size of int is 4 so it's 2000-1000/4=250

Answer 3

The meaning of p = (int *) 1000 is implementation-defined. But yes, in a typical implementation it will make p to point to address 1000 .

Doing *p = 22 afterwards will indeed attempt to store 22 at address 1000 . However, in general case this attempt will lead to undefined behavior, since you are not allowed to just write data to arbitrary memory locations. You have to allocate memory in one way or another in order to be able to use it. In your example you didn't make any effort to allocate anything at address 1000 . This means that most likely your program will simply crash, because it attempted to write data to a memory region that was not properly allocated. (Additionally, on many platforms in order to access data through pointers these pointers must point to properly aligned locations.)

Even if you somehow succeed succeed in writing your 22 at address 1000 , it does not mean that it will in any way affect "other programs". On some old platforms it would (like DOS, fro one example). But modern platforms implement independent virtual memory for each running program (process). This means that each running process has its own separate address 1000 and it cannot see the other program's address 1000 .

Answer 4

1. Yes, p is pointing to virtual address 1000. If you use *p = 22; , you are likely to get a segmentation fault; quite often, the whole first 1024 bytes are invalid for reading or writing. It can't affect another program assuming you have virtual memory; each program has its own virtual address space.

2. The value of q - p is the number of units of sizeof(*p) or sizeof(*q) or sizeof(int) between the two addresses.

Answer 5

Casting arbitrary integers to pointers is undefined behavior. Anything can happen including nothing, a segmentation fault or silently overwriting other processes' memory (unlikely in the modern virtual memory models).

But we used to use absolute addresses like this back in the real mode DOS days to access interrupt tables and BIOS variables :)

About qp == 250 , it's the result of semantics of pointer arithmetic. Apparently sizeof int is 4 in your system. So when you add 1 to an int pointer it actually gets incremented by 4 so it points to the next int not the next byte. This behavior helps with array access.

Answer 6

does this mean that p is pointing to 1000 address location?

yes. But this 1000 address may belong to some other processes address.In this case, You illegally accessing the memory of another process's address space. This may results in segmentation fault.