C Pointers: *ptr vs &ptr vs ptr - c

Question

Suppose *ptr points to a variable. What does *ptr, &ptr, and ptr each mean?
Many times, I get confused between them. Do anyone mind clarifying between those statements and give some concrete examples?

Answer 1

Take the following variables in a function.
int i = 0;
int* ptr = &i;
In the function, the memory layout could look something like:
Memory corresponding to i:
+---+---+---+---+
| 0 |
+---+---+---+---+
^
|
Address of i
Memory corresponding to ptr:
+---+---+---+---+
| address of i |
+---+---+---+---+
^
|
Address of ptr
In the above scenario,
*ptr == i == 0
ptr == address of i == address of memory location where the vale of i is stored
&ptr == address of ptr == address of memory location where the value of ptr is stored.
Hope that makes sense.

Answer 2

Here is a computer memory:
int i = 1023
If I want to print i, then I just have to do:
printf(..., i);
// out: 1023
If I want to print where i lives, then I just have to do:
printf(..., &i);
// out: 0x4
But let's say I want to remember where i lives:
int *i_ptr = &i; // i_ptr is a variable of type int *
Then I can print it this way:
printf(..., i_ptr);
// out: 0x04
But if just print out the value of i, I need a *:
printf(..., *i_ptr); // * also doubles as a way to follow the pointer
// out: 1023
Or I can just print out where i_ptr lives:
printf(..., &i_ptr);
// out: 0x32

Answer 3

Given the declarations
int i = 0x01234567;
int *ptr = &i;
the following are true:
Expression Type Value
---------- ---- -----
ptr int * Address of i
*ptr int Value stored in i (0x01234567)
&ptr int ** Address of ptr variable
In memory, it would look something like the following (assuming 32-bit int)
Item Address 0x01 0x02 0x03 0x04
---- ------- ---- ---- ---- ----
i 0x7fffbb00 0x01 0x23 0x45 0x67
ptr 0x7fffbb04 0x7f 0xff 0xbb 0x00
So the value of ptr is 0x7fffbb00, the value of &ptr is 0x7fffbb04, and the value of *ptr is 0x01234567.

Answer 4

Let's suppose you have:
int number = 5;
int *ptr = &number;
ptr will be the variable, of type int *, instead storing a 5 or
"foo", it will store an address like 0xf0f0f004 or whatever it is the
address of the variable number.
*ptr will be the value of what it is in this address of memory 0xf0f0f004, in this specific case is 5.
&ptr will be the address where it is located the variable that will
be in other place for example 0xff00ffaa or whatever.
ptr and number are located in different places in memory, both stores values, one just store a number and the other store an address. And the language allows you putting *, access the value of this address.

Answer 5

If *ptr points to a variable, then that would mean that *ptr is a pointer itself. That would mean you're declaring ptr as follows: int **ptr;
In this case:
ptr is a pointer to the pointer to your variable
*ptr is the pointer to your variable
&ptr gives you the address of ptr, so a pointer to the pointer to the pointer to your variable
For example:
//set up work
int x;
int *intermediatePtr;
int **ptr;
x = 5;
intermediatePtr = &x; //used only for additional level of indirection in this example
ptr = &intermediatePtr; //ie *ptr = &x;
//should print out the memory address for the pointer to the address of x
printf("%d", ptr);
//should print out the memory address of x (different memory location than above)
printf("%d", *ptr);
//should print out the memory address of the variable
//which holds the memory address of x
//(again, different memory location than both above examples)
printf("%d", &ptr);
If ptr points to a variable instead of *ptr (ie int *ptr; ptr = &x;), there is one less level of indirection than my above example.

Answer 6

int *ptr; // declares a pointer to integer.
int val; // declares an integer.
&val; // pointer to val
ptr = &val; // ptr will now point to val
*ptr = 5; // same as writing val = 5
ptr++; // pointer to the next int after val (in this case, it will be undefined behaviour, it is useful if this pointer pointed to a cell in an array)
int arr[10]; // declares an array of size 10
ptr = arr; // ptr now points to arr[0] (name of an array can be implicity cast to pointer to first element)
ptr++; // ptr now points to arr[1]

Answer 7

& = Reference
* = De reference
ptr is the identifier/name. You declare it by int *ptr.
Here is a small C program:
#include<stdio.h>
int main()
{
int *ptr,ref;
ptr= &ref;
ref=12;
printf("%d\n",*ptr );
}
In C,int *ptr is an integer pointer. You can use other data types like float, char etc,.
ptr = &ref gets the address of ref and stores in ptr. Since we declared ptr as integer pointer, when we print the value pointed, we have to De-reference it by using *.