C - Pointer Operators

Pointer operators in C are used to perform various operations on pointers, allowing you to manipulate memory addresses and access data efficiently. Let's go through each of the pointer operators and discuss their typical usage and behavior:

1. Address-of Operator (&):
   • Usage: The address-of operator (&) is used to obtain the memory address of a variable. It is typically used to initialize pointers or to pass the address of a variable to a function..
   • Output: It doesn't produce a visible output by itself. The result is the memory address of the variable.
   • Example:

     int x = 42;
     int* ptr = &x; // ptr now holds the address of x
     

2. Dereference Operator (*):
   • Usage: The dereference operator (*) is used to access the value stored at a memory address pointed to by a pointer. It retrieves the value from the address.
   • Output: The value stored at the memory address.
   • Example:

     int y = *ptr; // y now holds the value 42 (value at the address pointed to by ptr)
     

3. Member Access Operator (->):
   • Usage: The member access operator (->) is used to access members of a structure or a union through a pointer to that structure or union. It is a convenient way to access struct members..
   • Output: The value or member of the structure or union.
   • Example:

     struct Student {
     int id;
     char name[50];
     };
     
     struct Student student1;
     struct Student* ptr = &student1;
     
     ptr->id = 123; // Accesses and sets the 'id' member of student1
     

4. Pointer Arithmetic:
   • Usage: You can perform arithmetic operations on pointers to navigate through memory. Common pointer arithmetic includes addition and subtraction. It's important to ensure that pointer arithmetic stays within the bounds of allocated memory.
   • Output: The updated pointer position after the arithmetic operation.
   • Example:

     int arr[5] = {1, 2, 3, 4, 5};
     int* ptr = arr; // Point to the first element of the array
     
     ptr++; // Moves the pointer to the next memory location (second element)
     

5. Array Subscript Operator ([]):
   • Usage: The array subscript operator ('[]') can be used with pointers to access elements of an array. It allows you to treat a pointer as if it were an array.
   • Output: The value of the array element.
   • Example:

     int arr[5] = {1, 2, 3, 4, 5};
     int* ptr = arr; // Point to the first element of the array
     
     int value = ptr[2]; // Accesses the third element (value = 3)
     

The output of these pointer operators depends on the specific usage and the data they operate on. It's important to use them correctly to ensure that you access memory safely and obtain the expected results.