How pointers work in c?


A pointer is declared by putting an asterisk '*' before the variable name.

int var;     /* variable declaration */
int *ptr;   /* pointer declaration */

Asterisk and ampersand are the frequently used pointer operators.
& - used to get the address of the variable
*  - used to get the value to which the pointer points to

Let us understand the purpose of ampersand and asterisk operators.
var    - variable of type integer
&var  - pointer to an integer variable var
ptr     - pointer to an integer
*ptr   - integer

Consider the following example,
int var = 10;

  name: var
+-------------+
| value: 10  |
+-------------+
  addr: 3000

The above statement/diagram indicates that, var is the name of the variable and its address is 3000. The value at the address 3000 is 10.

int *ptr1, *ptr2;
ptr1 = &var;

  name: ptr1
+---------------+
| value: 3000 |
+---------------+
  addr: 6000

We have assigned the address of the variable var to pointer ptr.

ptr2 = ptr1;

  name: ptr2
+---------------+
| value: 3000 |
+---------------+
  addr: 7000

Now, we have assigned the value of pointer ptr1 to ptr2.  So, both ptr1 and ptr2 refers to the same address(3000).

If we dereference ptr1 or ptr2, we will get the value of the variable var.

Value of ptr1 and ptr2 is 3000.  The value at the memory location 3000 is 10.

  name: var
+-------------+
| value: 10  |
+-------------+
  addr: 3000

So, the value of *ptr1 and *ptr2 is 10.

If we change the value of *ptr1, *ptr2 or var, the same would be reflected in all places.(i.e). the values of *ptr1, *ptr2 and var will be updated with new value.

Let us change the value of *ptr1 to 20.  In this case, the value at the memory location 3000 is updated with new value 20.  So, the value of *ptr1, *ptr2 and var becomes 20.  It's because ptr1, ptr2 and &var points to the same memory location.

Let us describe the above operation using a simple c program.

  #include <stdio.h>
  int main() {
        int var = 10;
        int *ptr1, *ptr2;
        /* assigning addresss of variable var */
        ptr1 = &var;
        /* assinging value of ptr1 to ptr2 */
        ptr2 = ptr1;

        /* printing the addresses and values of variables */
        printf("Address of var is 0x%x\n", &var);
        printf("Address of ptr1 is 0x%x\n", &ptr1);
        printf("Address of ptr2 is 0x%x\n", &ptr2);
        printf("Value of var is %d\n", var);
        printf("Value of ptr1 is 0x%x\n", ptr1);
        printf("Value of ptr2 is 0x%x\n", ptr2);
        printf("Value of *ptr1 is %d\n", *ptr1);
        printf("Value of *ptr2 is %d\n", *ptr2);

        /* updating the value of *ptr2 */
        *ptr2 = 25;
        printf("\n\n###############################\n");
        printf("Changed the value of *ptr2 to %d\n", *ptr2);

        /* printing the addresses and values of variables */
        printf("Address of var is 0x%x\n", &var);
        printf("Address of ptr1 is 0x%x\n", &ptr1);
        printf("Address of ptr2 is 0x%x\n", &ptr2);
        printf("Value of var is %d\n", var);
        printf("Value of ptr1 is 0x%x\n", ptr1);
        printf("Value of ptr2 is 0x%x\n", ptr2);
        printf("Value of *ptr1 is %d\n", *ptr1);
        printf("Value of *ptr2 is %d\n", *ptr2);

        *ptr1 = 30;
        printf("\n\n################################\n");
        printf("Changed the value of *ptr1 to %d\n", *ptr1);
        printf("Address of var is 0x%x\n", &var);
        printf("Address of ptr1 is 0x%x\n", &ptr1);
        printf("Address of ptr2 is 0x%x\n", &ptr2);
        printf("Value of var is %d\n", var);
        printf("Value of ptr1 is 0x%x\n", ptr1);
        printf("Value of ptr2 is 0x%x\n", ptr2);
        printf("Value of *ptr1 is %d\n", *ptr1);
        printf("Value of *ptr2 is %d\n", *ptr2);

        var = 33;
        printf("\n\n################################\n");
        printf("Changed the value of var to %d\n", var);
        printf("Address of var is 0x%x\n", &var);
        printf("Address of ptr1 is 0

Comments

Post a Comment

Popular posts from this blog

Operators And Separators In C Language Operators in C Language:

Below are various operators available in C Programming language.  They are used to perform operations arithmetic, logical, relational, bitwise, assignment, etc.  We will see more about all the below operators in details in the forth coming chapters. Operators Name Of Operators [ ] ( ) . -> ++ -- Array subscript Function Call Structure reference Structure dereference Postfix increment/Postfix decrement ++ -- + - ! ~ (type) *  & sizeof Prefix increment/Prefix decrement Unary plus/Unary minus Logical negation/One's complement Typecast operator Pointer dereference/Address of Size of type/variable in bytes *  /  % Multiplication/Division/Modulo + - Addition/Subtraction <<   >> Bitwise left shift/ Bitwise right shift <    > <= >= Comparison less than/Comparision greater than Comparison less than or equal to Comparison greater than or equal to ==   != Comparison equal to/Comparison not equal to & Bitwise AND ^ Bitwise XOR
Read more

Difference between asterisk and ampersand operators in c

Address Operator (& - Ampersand): Returns address of the given variable.  Consider the following example, int *ptr, var = 10; ptr = &var; ptr = &var sets the address of the variable var to pointer ptr.  & is also called as reference operator. Let us try to understand the purpose of reference operator using the following example program.   #include <stdio.h>   int main() {         int var = 10, *ptr;         /* assigning address of variable var to pointer ptr */         ptr = &var;         /* printing the address of the variable var */         printf("Address of var is 0x%x\n", &var);         /* printing the value of pointer ptr */         printf("Value of ptr is 0x%x\n", ptr);         return 0;   }   Output:   jp@jp-VirtualBox:~/$ ./a.out   Address of var is 0xbfdf202c   Value of ptr is 0xbfdf202c Indirection Operator('*' - asterisk): The dereference operator is an unary operator which returns the value of
Read more