C dereference pointer

by

In the C programming language, the dereference operator (*) is used to access the value stored at the memory address pointed to by a pointer. Here’s how you can dereference a pointer in C:

#include <stdio.h>

int main() {
    int number = 42;
    int *ptr = &number;  // pointer to an integer

    printf("Value of number: %d\n", *ptr);  // Dereference the pointer using *

    return 0;
}

In the above example, we declare an integer variable number and assign it the value of 42. Then, we declare a pointer ptr to an integer and initialize it with the address of the number variable using the address-of operator (&).

To dereference the pointer and access the value stored at the memory location it points to, we use the asterisk (*) operator. In this case, *ptr will give us the value of number (42).

Why we use dereferencing pointer?

Dereferencing a pointer in C allows you to access the value stored at the memory address pointed to by the pointer. It is useful in several scenarios:

  1. Accessing and manipulating data: Pointers provide a way to indirectly access and modify data. By dereferencing a pointer, you can read or modify the value stored at the memory location it points to. This allows you to work with the actual data rather than just the address.
  2. Dynamic memory allocation: Pointers are often used in conjunction with dynamic memory allocation functions like malloc() and calloc(). After allocating memory dynamically, you can store values in that memory block by dereferencing the pointer to access the allocated memory location.
  3. Passing arguments to functions: Pointers can be used to pass arguments to functions by reference. When you pass a pointer to a function, the function can modify the value pointed to by the pointer, and the changes will be reflected in the caller’s scope. Dereferencing the pointer inside the function allows you to access and modify the value being pointed to.
  4. Working with complex data structures: Pointers are commonly used to work with complex data structures like arrays, linked lists, and trees. Dereferencing pointers allows you to access individual elements or nodes in these data structures, enabling efficient traversal and manipulation.
  5. Pointers to functions: In C, you can have pointers that point to functions. Dereferencing such a function pointer allows you to invoke the function indirectly, providing a flexible mechanism for function invocation based on runtime decisions.

Dereferencing pointers is essential for working with dynamically allocated memory, passing arguments by reference, and manipulating complex data structures. It enables you to access and modify data indirectly, providing flexibility and efficiency in various programming scenarios.

C dereference pointer example:

Certainly! Here’s an example that demonstrates the dereferencing of a pointer in C:

#include <stdio.h>

int main() {
    int number = 42;
    int *ptr = &number;  // pointer to an integer

    printf("Value of number: %d\n", *ptr);  // Dereference the pointer using *

    *ptr = 100;  // Modify the value using the dereferenced pointer

    printf("Modified value of number: %d\n", number);  // Print the modified value

    return 0;
}

In this example, we have an integer variable number with an initial value of 42. We declare a pointer ptr to an integer and initialize it with the address of number using the address-of operator (&).

To dereference the pointer and access the value it points to, we use the asterisk (*) operator. In the printf statement, *ptr retrieves the value stored at the memory location pointed to by ptr, which is the value of number.

In the next line, we modify the value of number indirectly by assigning a new value (100) to the memory location pointed to by ptr, using the dereference operator *. This change affects the original variable number as well.

Finally, we print the modified value of number to confirm that the change made through the dereferenced pointer is reflected in the original variable.