C - What does int *p; p=15; does?

Question

What is the difference between these two code samples? When I print the variable p, it prints the assigned value like below.

int *p;
p = 51;
printf("%d",p);

Output: 51

When I try to assign p=15, am I making memory address "15" in the ram as a pointee to the pointer p? When I try to add int c = 5 +p; it gives output as 71. Why am I getting 71?

I thought that the memory address "15" could store any information of the OS, programs, etc. But it exactly stores int for precise. Though I change the value p = 150; it gives int . How is that possible? What's happening under the hood?! I really don't understand.

Answer 1

Your code is illegal. Formally, it is not C. C language prohibits assigning integral values to pointer types without an explicit cast (with the exception of constant 0)

You can do

p = (int *) 51;

(with implementation-defined effects), but you cannot do

p = 51;

If your compiler allows the latter variant, it is a compiler-specific extension that has nothing to do with standard C language.

Typically, such assignment makes p to point to address 51 in memory.

On top of that, it is illegal to print pointer values with %d format specifier in printf. Either use %p or cast pointer value to proper integer type before using integer-specific format specifiers.

Answer 2

So you're telling that pointer that it points to 0x15. Then, you tell printf to print it as a decimal integer, so it treats it as such.

This reason this works is that on a 32 bit system, a pointer is 4 bytes, which matches the size of an int.

Answer 3

p points to a place in memory. *p is the contents of that space. But you never use the contents, only the pointer.

That pointer can be viewed as just a number, so printf("%d",p) works. When you assign a number to it, it interprets that as an offset into memory (in bytes). However, the pointer is supposed to contain ints, and when you add a number to a pointer, the pointer advances by that many spaces. So p+5 means "point to the int 5 spaces past the one you're pointing at now", which for 4-byte ints means 20 bytes later, hence the 71.

Otherwise, you've said you have a pointer to an int, but you're actually just doing all your stuff to the pointer, not the int it's pointing to.

If you actually put anything into the place you were pointing, you'd run into all kinds of trouble. You need to allocate some unused memory for it (e.g. with malloc), and then read and write values to that memory using *p.