Actual vs. Formal Parameters in C: Key Application Scenarios

1 year ago
Jackson Davis
3 minutes

In C programming, understanding the distinction and application scenarios of actual parameters (arguments) and formal parameters is crucial for writing effective and modular code. These parameters facilitate communication between different parts of a program, particularly between calling functions and called functions.

1. Function Calls

This is the most common scenario. When a function is called, actual parameters (the values or variables passed during the call) are used to initialize the formal parameters (the variables declared in the function’s definition). This allows the function to operate on specific data provided by the caller.

void addNumbers(int a, int b) { // a, b are formal parameters
    // ... operations using a and b
}

int main() {
    int x = 10, y = 20;
    addNumbers(x, y); // x, y are actual parameters
    return 0;
}

2. Array Passing

When an array is passed to a function in C, the array name itself acts as a pointer to its first element. The formal parameter in the function definition receives this pointer, allowing the function to access and manipulate the elements of the original array.

void printArray(int arr[], int size) {
    // ... iterate and print array elements
}

int main() {
    int numbers[] = {1, 2, 3};
    printArray(numbers, 3);
    return 0;
}

3. Structure Passing

Structures can be passed to functions either by value or by reference (using pointers). Passing by value creates a copy of the structure, while passing by reference allows the function to modify the original structure.

struct Point {
    int x;
    int y;
};

void movePoint(struct Point *p, int dx, int dy) {
    p->x += dx;
    p->y += dy;
}

int main() {
    struct Point myPoint = {1, 2};
    movePoint(&myPoint, 5, 10);
    return 0;
}

4. Dynamic Memory Allocation

When functions need to allocate memory dynamically (e.g., using malloc or calloc) and return a pointer to that memory, the size or other allocation parameters can be passed as actual parameters. The function then uses these to allocate memory, and the returned pointer can be stored in an actual parameter (if passed by reference) or returned directly.

int* createDynamicArray(int size) {
    int* arr = (int*)malloc(size * sizeof(int));
    return arr;
}

int main() {
    int* myArr = createDynamicArray(10);
    // ... use myArr
    free(myArr);
    return 0;
}

5. Pointer Passing for Value Modification

To modify the value of an actual parameter within a function (pass-by-reference), a pointer to the actual parameter is passed. The formal parameter then becomes a pointer, allowing dereferencing to change the original variable’s value.

void increment(int *num) {
    (*num)++;
}

int main() {
    int count = 5;
    increment(&count); // count becomes 6
    return 0;
}

6. Callback Functions

Function pointers can be passed as actual parameters, allowing a function to call another function (a “callback”) whose address was provided by the caller. This is common in event handling, sorting algorithms, and custom comparators.

void executeOperation(void (*callback)()) {
    // ... some logic
    callback(); // Call the function passed as a parameter
}

void myCallback() {
    printf("Callback function executed!\n");
}

int main() {
    executeOperation(myCallback);
    return 0;
}

These diverse scenarios highlight the flexibility and power of parameters in C, enabling modular design, data manipulation, and dynamic program behavior.

bannerAds