Pointers in C, why this output?

Question

Hey I'm fairly new to programming in C, and I'm trying to understand pointers and addresses and running this code I get the output: v = 3003 'a memory address' *p = 3003

I understand the last two, but could someone help explain why v = 3003? My initial understanding would be that it results in 3002, so i understand the addressing and pointer line 'p = &v' is playing a role in this but i don't understand how. Any explanation would be much appreciated thank you!

#include <stdio.h>
int main() {
    int v = 0x3002;
    int* p = 0x3000;
    p = &v;
    (*p)++;
    printf("v = %x\n", v);
    printf("%x\n", p);
    printf("*p = %x\n", *p);
}

Answer 1

The behaviour of your code is undefined. You cannot assign an address to a pointer which corresponds to memory that you don't own, with the exceptions of NULL, one past the end of an array, or one past the end of a scalar. (For some reason, this is a little known rule.)

So your first job is to remove int* p = 0x3000;. Replace with int* p;. Then the undefined behaviour goes away.

Your code

p = &v;
(*p)++;

is setting the p to the address of v, and incrementing v via the pointer.

Answer 2

p = &v;

p now contains address of v.

(*p)++;

Increase the value that is at the address contained in p. That value is 0x3002;

So it becomes 0x3003.

Now v is changed via p.

That's why that output.

You can assign to pointer via casting.

int *p=(int*)0x3000;

The code will be :-

#include <stdio.h>
int main() {
    int v = 0x3002;
    int* p;
    p=&v; 
    (*p)++;
    printf("v = %x\n", v);
    printf("%x\n", p);
    printf("*p = %x\n", *p);
}

Also assigning to a pointer variable is undefined behavior

From standard §6.3.2.3

An integer may be converted to any pointer type. Except as previously specified, the result is implementation-defined, might not be correctly aligned, might not point to an entity of the referenced type, and might be a trap representation.)

Answer 3

The p=&v statement assigns the address of the variable v to p. In other words, from then on, p is pointing to the memory address where v stores its value. Then (*p)++ increments it: p is a pointer in memory, *p is dereferencing this address so that the increment operation ++ does not apply to p (in which case p would point to the next memory address) but to the value at the address given by p.

Answer 4

First of all, before going into the details of pointer , the Memory access provided by C language is dangerous to use in this way. usually you don't define the addresses of the locations you want to save variable at or the address of the pointer itself as you mentioned in the code.

#include <stdio.h>
int main() {
    int v = **0x3002**;
    int* p = **0x3000;**
    p = &v;
    (*p)++;
    printf("v = %x\n", v);
    printf("%x\n", p);
    printf("*p = %x\n", *p);
}

However, the value you assign to p is neglected since you are using p = &v , the p has the correct address assigned to v by compiler or OS. when you define int v; at run time a memory location is allocated then p will get the address.

in general you are trying to make an integer variable and a pointer to this variable to have two references to the same variable.

In general you don't need to keep track of the address values for variable or pointers when you are using them , you just need to know how to use them properly and when to use them

General Examlpe for pointer usage

#include <stdio.h>
void changeA( int*);
int main() {
   int a=1;
   printf("%d",a);
   changeA(&a);
   printf("%d",a);
   return 0;
}

void changeA(int* pA){
  *pA=2;
}

Output 1 2

the previous example shows the usage of pointers where you can access variables with a different scope , variable a is defined within the scope of main function , and by using the pointers by providing the address of the variable a for the function changeA the function can access the memory location where the variable a is saved in the memory and change it directly from another function scope.

usually pointers used when you need to have multiple outputs for a function and the return can be used to return only one variable. with pointers you will have unlimited capabilities of each function.

Answer 5

here is a correctly written version of the posted code, with appropriate comments

#include <stdio.h>

int main( void ) 
{
    int v = 0x3002;   // sets an integer value into 'v'
    int* p = &v;      // get address of 'v' and places that address in 'p'
    (*p)++;           // increments the contents of 'v', 
                      // using 'p' 
                      // while paying attention to operator precedence in C

    // displays on terminal, the contents of 'v' I.E.0x3003
    printf("v = %x\n", v);   

    // displays on terminal, the address of 'v' (contents of 'p')
    printf("%p\n", (void*)p);

    // displays on terminal, the contents of 'v', which is pointed to by 'p'
    printf("*p = %x\n", (unsigned int)*p);
}