When do we add * to a pointer?

Question

In C, the pointer is always my pain.

My question: When we add * to a pointer?

I see those two code:

First one:

int x;
int *ptr;
ptr = &x;

Second one:

int x;
int *ptr;
*ptr = 5;

Why first pointer has * in front of the pointer, but the second pointer does not?

Update: Why we don't do *pr = &x and ptr = 5?

Answer 1

A variable holds a value, and that value is stored somewhere in memory (at an address). A pointer is a variable that holds as a value an address.

One use of * is in declaring a pointer; in the posted code, int *ptr; declares a pointer to int. The expression &x evaluates to the address of x, and so ptr = &x; stores the address of the variable x in the (pointer) variable ptr. If you use the variable ptr alone, as in:

printf("ptr = %p\n", (void *) ptr);

ptr will evaluate to the value stored in ptr, which is the address of x. Note here that the %p conversion specifier is needed to print a pointer value, and that it must be cast to (void *) to avoid undefined behavior.

If you want to use the value stored in the variable pointed to by a pointer, you dereference the pointer, using the * operator. That is, if you want to use ptr to obtain the value stored in x, you use *ptr:

printf("*ptr = x = %d\n", *ptr);

Similarly, if you want to store a value in a variable pointed to by a pointer, you can dereference the pointer:

*ptr = 5;
printf("x is now %d\n", x);

Now note that in your first code snippet, x is uninitialized (holds an indeterminate value), but x has been defined, and has an address, so ptr does hold a determinate value. But in the second code snippet, ptr is uninitialized, and so holds an indeterminate value. It is undefined behavior to use an indeterminate value, so in this case the line:

*ptr = 5; 

causes undefined behavior.

Here is a version of the posted code that avoids undefined behavior:

#include <stdio.h>

int main(void)
{
    int x;
    int *ptr;

    ptr = &x;
    printf("ptr = %p\n", (void *) ptr);

    x = 1;
    printf("*ptr = x = %d\n", *ptr);

    *ptr = 5;
    printf("x is now %d\n", x);

    return 0;
}

Answer 2

* in the declaration just specifies that this variable is a pointer. * when using the variable (i.e., anywhere other than the declaration) means you want to access whatever thing the pointer points to, rather than the pointer itself.

Leave the * out when you want to make the pointer point to a different object than it pointed to before (whatever's on the right should be an address of something):

ptr = &thing_it_points_to;

Use a * when you want the pointer to stay pointing to the same object, but change that object's value: *ptr = 5; // 5 is not an address here, it's the value I'm assigning to the int that this points to

So, your first one:

int x;
int *ptr; // * while declaring the variable tells us this is a pointer type
ptr = &x; // Get a pointer that points to 'x', and store it in 'ptr'

Second one:

int x;
int *ptr; // * while declaring the variable tells us this is a pointer type
*ptr = 5; // * while using the variable means to get the thing this pointer points to, and set it to 5

BTW, both of these are invalid code; x is used before being initialized in the first one, and ptr is used before being initialized in the second one.

Answer 3

Pointers can be suuuupppeerrr confusing.

To start, a pointer is a variable that stores the address of another variable.

When you declare a pointer, you need to declare it with a *. C is a statically-typed language and you need to define the type of the variable before assigning it.

So, int *ptr is declaring a integer pointer. char *string is a char pointer.

However, after declaring, when you use the * again it's for dereferencing the pointer. You can basically "read" that as "the value of" the memory address the pointer is pointing at.

Example:

int *ptr;
int x;

x = 10;
/*
* store the address of x in ptr
* so ptr is now pointing to x
*/
ptr = &x

/*
* this is printing the pointer
* which is pointing to the address of x
* so this will print you a memory address
* Output will be something like: 0x7fff9575c05f
*/
printf("%p\n", ptr);

/*
* this prints the value of the memory address
* save which is the value of x
* so in this case, this will print 10
*/    
printf("%i\n", *ptr);

Answer 4

If * appear in declaration, for example:

It is declaring a pointer variable pt, not pointer variable *pt. variable pt is pointing to int type, and you can use it to store an address.

int *ptr;
ptr = &x;

If * appear in the an assignment statement, It is dereferencing a pointer, *ptr actually would means get the data/value in the memory that the pointer points to.

*ptr = 5;

It means to assign integer 5 to the content of pointer variable `ptr.

Why we don't do *pr = &x and ptr = 5?

*pr = &x and ptr=5 is actually (i) assigning address of x to the value of the pointer pointing to (ii) assigning an integer to an pointer variable

which cause an error/ undefined behavior.

Answer 5

So basically pointers in C store an address to a particular memory.

Any variable(such as the x in the above example) is stored in a location in the memory and therefore can be used a pointer to represent the location.

In C, the operation of getting the location of a variable in the memory is using the operator &, so ptr = &x means getting the pointer that points to the memory storing x and store the location into the pointer ptr.

And getting the variable at the location of a pointer is the operator * at the front of the pointer, so *ptr = 5 means setting the 4 bytes of memory that the pointer ptr points to 5.

However, the x in the first code is uninitialized, resulting in undefined behavior, and ptr in the second code is also uninitialized, and the statement *ptr = 5 certainly result in a runtime error because the memory ptr represents cannot be modified by the program. So strictly speaking, both of your code is invalid.

Answer 6

In your code

int *ptr;
ptr =&x;

here ptr is looking for an address to store an integer of int type.

Eg: 0x77C79AB2

*ptr = 5;

here ptr looks for an integer and not an address.

Eg: 5 // (some number)

Because address is not treated as integer. You need to cast it to use as an integer

In your question

*ptr = &x and ptr =5

will throw error as it couldn't find the integer in the first and address in the second

Answer 7

As others have pointed out, '*' can be used to tell the compiler and other programmers that you are declaring a variable that holds an address. On the first case, you are storing taking the address of variable x(using '&') and storing in ptr. On the second case, you are taking the value that the address ptr stores has. So you have something like this:

--------------      --------------
|    ptr     |      |      x     |
|++++++++++++|      |++++++++++++|
|  xaddress  |----->|   xvalue   |       
|++++++++++++|      |++++++++++++|

You say ptr points to x because ptr is holding x's address.

Now really, pointers are just a convenience feature from the language. You don't have to use pointers to store addresses, although you should. The following is perfectly valid:

int x;
int ptr;
ptr = &x;

but you lose on readability and the convenience pointer arithmetic provides. If you did ptr+1 you would only advance 1 byte instead of 4 if you had declared ptr as a pointer. Furthermore, eventually you would want to access the contents of the address stores in your integer variable, so you would have to make an ugly cast, like so: * (int*)ptr and you would have to be extra careful because integer sizes are not always the same as integer pointer sizes. Your pointer might be 8 bytes and the integer might be 4, so you would actually have to declare long long ptr = &x;