C Pointer Arguments

Pointer Arguments

In the context of the C programming language, "arguments" typically refer to the values or expressions that are passed to a function or program when it is called. These arguments provide data to the function or program, which can then use them for various computations, operations, or processing.

You can pass arguments to functions by value or by reference using pointers. When you pass arguments by reference using pointers, you allow the function to modify the original data passed to it. This is a powerful feature in C and is often used for various purposes, including passing arrays, dynamically allocating memory, and more.

Here's how you can use pointer arguments in C:

• Passing arguments by reference:

To pass arguments by reference, you need to pass a pointer to the data you want to work with. The receiving function can then dereference the pointer to access and modify the original data.

#include ＜stdio.h>

// Function that swaps two integers using pointers
void swap(int *a, int *b) {
    int temp = *a;
    *a = *b;
    *b = temp;
}

int main() {
    int x = 5, y = 10;
    printf("Before swap: x = %d, y = %d\n", x, y);
    swap(&x, &y);
    printf("After swap: x = %d, y = %d\n", x, y);
    return 0;
}

Before swap: x = 5, y = 10
After swap: x = 10, y = 5

• Passing arrays:

Arrays are usually passed to functions by reference because they decay into pointers to their first element. You don't need to use the address-of operator (&) to pass an array to a function.

#include ＜stdio.h>

// Function to find the sum of an array of integers
int sum(int arr[], int size) {
    int total = 0;
    for (int i = 0; i < size; i++) {
        total += arr[i];
    }
    return total;
}

int main() {
    int numbers[] = {1, 2, 3, 4, 5};
    int result = sum(numbers, 5);
    printf("Sum: %d\n", result);
    return 0;
}

Sum: 15

• Dynamic memory allocation:

Pointers are commonly used to allocate and work with dynamically allocated memory in C. Functions like 'malloc' and 'free' are used to allocate and de-allocate memory, and pointers are used to pass around references to this dynamically allocated memory.

#include ＜stdio.h>
#include ＜stdlib.h>

// Function that allocates and initializes an integer dynamically
int *createInt() {
    int *ptr = (int *)malloc(sizeof(int));
    if (ptr != NULL) {
        *ptr = 42;
    }
    return ptr;
}

int main() {
    int *dynamicInt = createInt();
    if (dynamicInt != NULL) {
        printf("Dynamically allocated integer: %d\n", *dynamicInt);
        free(dynamicInt); // Don't forget to free the memory
    }
    return 0;
}

Dynamically allocated integer: 42

void modifyValue(int x) {
    x = 10;
}

int main() {
    int num = 5;
    modifyValue(num);
    // num is still 5
    return 0;
}

void modifyValueByReference(int *x) {
    *x = 10;
}

int main() {
    int num = 5;
    modifyValueByReference(&num);
    // num is now 10
    return 0;
}