Function Parameters

In C, you can simulate pass by reference using pointers. This allows a function to modify the original variable by passing its address. It's essential for tasks like swapping values or updating data inside a function.

Syntax:

return_type function_name(data_type *pointer_name) {
    *pointer_name = new_value;  // modifies the ORIGINAL variable
}

// Calling the function
function_name(&variable);  // passes the ADDRESS of 'variable'

Basic Pointer Parameter Example

#include <stdio.h>

void setZero(int *p) {
    *p = 0;  // Dereference and modify
}

int main() {
    int x = 10;
    printf("Before: %d\n", x);
    setZero(&x);  // Pass address of x
    printf("After: %d\n", x);
    return 0;
}

Output:

Before: 10
After: 0

The Classic Swap Problem

One of the most common interview questions is swapping two variables. This demonstrates why pass by reference is essential for certain operations.

void swapWrong(int a, int b) {
    int temp = a;
    a = b;
    b = temp;
    // Only swaps local copies!
}

int main() {
    int x = 5, y = 10;
    swapWrong(x, y);
    printf("x=%d, y=%d\n", x, y);
    // Output: x=5, y=10 (unchanged!)
    return 0;
}

void swapCorrect(int *a, int *b) {
    int temp = *a;
    *a = *b;
    *b = temp;
    // Swaps actual values!
}

int main() {
    int x = 5, y = 10;
    swapCorrect(&x, &y);
    printf("x=%d, y=%d\n", x, y);
    // Output: x=10, y=5 (swapped!)
    return 0;
}

Understanding the & and * Operators

Two operators are essential for pass by reference: the address-of operator (&) and the dereference operator (*).

Declare Variable and Pointer

int number = 42;
int *ptr = &number;  // ptr stores the address of number

The & operator gets the memory address of number. The pointer ptr stores this address as its value. Now ptr "points to" the memory location where number lives. Both variables are now connected through this address.

Access Values and Addresses

printf("Value of number: %d\n", number);           // 42
printf("Address of number: %p\n", (void*)&number); // 0x7ffd...
printf("Value of ptr (address): %p\n", (void*)ptr);// Same address
printf("Value at ptr (*ptr): %d\n", *ptr);         // 42

The *ptr dereferences the pointer to get the value at that address. Dereferencing means "go to the address stored in the pointer and get the value there". Since ptr points to number, *ptr gives us 42. This is how we access data through pointers.

Modify Through Pointer

*ptr = 100;  // Changes 'number' through the pointer
printf("number = %d\n", number);  // Now 100!

Assigning to *ptr changes the original variable. This works because ptr and number share the same memory. When we write to *ptr, we're writing directly to that memory location. This is the key to modifying variables through pointers.

Multiple Output Parameters

Functions can only return one value. But what if you need to return multiple values? Use pointer parameters as "output parameters" to store multiple results.

Define a Function with Multiple Outputs:

// Returns both quotient and remainder through pointers
void divide(int dividend, int divisor, int *quotient, int *remainder) {
    *quotient = dividend / divisor;
    *remainder = dividend % divisor;
}

Input parameters (dividend, divisor) are passed by value. Output parameters (quotient, remainder) are pointers. The function writes results directly to the memory locations provided. This pattern allows returning multiple values from a single function.

Use the Function:

int main() {
    int a = 17, b = 5;
    int q, r;  // Variables to receive the results
    
    divide(a, b, &q, &r);  // Pass addresses of q and r
    
    printf("%d / %d = %d with remainder %d\n", a, b, q, r);
    // Output: 17 / 5 = 3 with remainder 2
    return 0;
}

The function stores results directly into q and r through their addresses. We pass &q and &r to give the function access to these variables. After the function returns, q contains 3 and r contains 2. This is how C functions return multiple values.

Output:

17 / 5 = 3 with remainder 2

Success/Failure Pattern with Output Parameters

A common C pattern is to return a success/failure status while using an output parameter for the actual result. This allows for proper error handling.

Define a Safe Function with Error Handling:

// Returns true on success, false on error
// Result is stored in *result
bool safeDivide(int a, int b, int *result) {
    if (b == 0) {
        return false;  // Division by zero!
    }
    *result = a / b;
    return true;
}

The function returns a boolean for success/failure status. The actual result is stored through the pointer parameter. This pattern separates error handling from the computed result. Callers can check the return value before using the result.

Use the Function with Error Checking:

int main() {
    int result;
    
    // Successful division
    if (safeDivide(10, 2, &result)) {
        printf("10 / 2 = %d\n", result);  // 10 / 2 = 5
    } else {
        printf("Error: Division by zero!\n");
    }
    
    // Failed division (divide by zero)
    if (safeDivide(10, 0, &result)) {
        printf("10 / 0 = %d\n", result);
    } else {
        printf("Error: Division by zero!\n");  // This prints
    }
    return 0;
}

Output:

10 / 2 = 5
Error: Division by zero!

Modifying Structures via Pointers

When working with structures, passing by pointer is essential for both efficiency (avoiding copies) and the ability to modify the original.

Define a Structure

struct Student {
    char name[50];
    int age;
    float gpa;
};

A structure groups related data together into a single unit. This Student struct holds name, age, and GPA fields. Structures help organize complex data in a meaningful way. They can be passed to functions just like simple variables.

Function to Modify Structure via Pointer

void updateGPA(struct Student *s, float newGPA) {
    s->gpa = newGPA;  // Arrow operator for pointer to struct
}

Use the arrow operator (->) to access members through a pointer. The expression s->gpa is equivalent to (*s).gpa. This modifies the actual structure in the caller's memory. The arrow operator makes pointer-to-struct code much cleaner.

Function to Read Structure (const pointer)

void displayStudent(const struct Student *s) {
    printf("Name: %s, Age: %d, GPA: %.2f\n", s->name, s->age, s->gpa);
}

Use const for read-only access - documents intent and prevents mistakes. The compiler will catch any attempts to modify the structure. This is a best practice for functions that only need to read data. It makes your code safer and more self-documenting.

Using the Functions

int main() {
    struct Student student = {"Alice Johnson", 20, 3.5};
    
    displayStudent(&student);    // Pass address for reading
    updateGPA(&student, 3.8);    // Pass address for modifying
    displayStudent(&student);    // Shows updated GPA
    return 0;
}

Output:

Before update:
Name: Alice Johnson, Age: 20, GPA: 3.50
After update:
Name: Alice Johnson, Age: 20, GPA: 3.80

NULL Pointer Safety

A major risk with pointer parameters is receiving a NULL pointer. Always validate pointers before dereferencing to prevent crashes.

❌ Unsafe: No NULL Check

void unsafeIncrement(int *ptr) {
    *ptr += 1;  // Crash if ptr is NULL!
}

Dereferencing NULL causes undefined behavior (usually a crash). NULL means the pointer doesn't point to valid memory. Attempting to read or write through NULL is a common bug. Always check for NULL before dereferencing pointers.

✓ Safe: Check for NULL

void safeIncrement(int *ptr) {
    if (ptr != NULL) {
        *ptr += 1;
    }
}

Always validate pointers before using them. This check prevents the crash that would occur with NULL. If the pointer is NULL, the function simply does nothing. This is called defensive programming - handle bad inputs gracefully.

✓ Even Better: Return Status Code

int safeIncrementWithStatus(int *ptr) {
    if (ptr == NULL) {
        return -1;  // Error code
    }
    *ptr += 1;
    return 0;  // Success
}

Returning a status lets the caller know if the operation succeeded. Here, -1 indicates an error and 0 indicates success. The caller can check the return value and handle errors appropriately. This pattern is common in C system programming and libraries.

Usage:

int main() {
    int x = 5;
    
    // Safe usage
    safeIncrement(&x);
    printf("x = %d\n", x);  // x = 6
    
    // This would crash with unsafeIncrement:
    // unsafeIncrement(NULL);
    
    // Safe version handles NULL gracefully
    safeIncrement(NULL);  // Does nothing, no crash
    
    return 0;
}

Pass by Value vs Pass by Reference Comparison

In C, arrays are always passed to functions as pointers to their first element. This means the function can modify the original array, but the array size information is not passed automatically. Understanding this is key to safe and effective array manipulation.

Syntax:

// Three equivalent ways to declare array parameters:
return_type function_name(data_type arr[], int size);      // Most common
return_type function_name(data_type *arr, int size);       // Pointer notation
return_type function_name(data_type arr[10], int size);    // Size is ignored!

// Calling the function
function_name(array_name, array_size);  // array decays to pointer

Basic Array Passing

When you pass an array to a function, C automatically converts it to a pointer to the first element. This process is called array decay.

#include <stdio.h>

void printArray(int arr[], int size) {
    for (int i = 0; i < size; i++) {
        printf("%d ", arr[i]);
    }
    printf("\n");
}

int main() {
    int data[5] = {10, 20, 30, 40, 50};
    
    printArray(data, 5);  // Pass array and its size
    
    return 0;
}

Output:

10 20 30 40 50

Why Size Must Be Passed Separately

A common beginner question: "Why can't the function figure out the array size?" The answer lies in how C handles arrays.

#include <stdio.h>

void demonstrateSizeProblem(int arr[]) {
    // sizeof(arr) returns pointer size, NOT array size!
    printf("Inside function: sizeof(arr) = %zu bytes\n", sizeof(arr));
    printf("This is the size of a pointer, not the array!\n");
}

int main() {
    int numbers[10] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
    
    printf("In main: sizeof(numbers) = %zu bytes\n", sizeof(numbers));
    printf("Array has %zu elements\n", sizeof(numbers) / sizeof(numbers[0]));
    
    demonstrateSizeProblem(numbers);
    
    return 0;
}

Output (on 64-bit system):

In main: sizeof(numbers) = 40 bytes
Array has 10 elements
Inside function: sizeof(arr) = 8 bytes
This is the size of a pointer, not the array!

Modifying Arrays in Functions

Since arrays are passed as pointers, any modifications inside the function affect the original array. This is different from pass by value with simple variables.

Define Functions to Modify Arrays

// Double each element in the array
void doubleElements(int arr[], int size) {
    for (int i = 0; i < size; i++) {
        arr[i] *= 2;  // Modifies original array!
    }
}

// Set all elements to a specific value
void fillArray(int arr[], int size, int value) {
    for (int i = 0; i < size; i++) {
        arr[i] = value;
    }
}

These functions modify the original array directly since arrays are passed as pointers. When you pass an array to a function, C passes a pointer to the first element. Any changes made inside the function affect the original array. This is different from simple variables which are copied.

Create a Helper Function for Printing

void printArray(int arr[], int size) {
    printf("{ ");
    for (int i = 0; i < size; i++) {
        printf("%d ", arr[i]);
    }
    printf("}\n");
}

A reusable function to display array contents. This function iterates through the array and prints each element. Notice we must pass the size since arrays decay to pointers. The function cannot determine the array size on its own.

Test the Modifications

int main() {
    int data[5] = {1, 2, 3, 4, 5};
    
    printf("Original: ");
    printArray(data, 5);
    
    doubleElements(data, 5);
    printf("After doubling: ");
    printArray(data, 5);
    
    fillArray(data, 5, 0);
    printf("After fill with 0: ");
    printArray(data, 5);
    
    return 0;
}

Output:

Original: { 1 2 3 4 5 }
After doubling: { 2 4 6 8 10 }
After fill with 0: { 0 0 0 0 0 }

Common Array Operations

Here are some commonly needed array functions that demonstrate proper array passing patterns.

Function 1: Sum All Elements

int sumArray(const int arr[], int size) {
    int sum = 0;
    for (int i = 0; i < size; i++) {
        sum += arr[i];
    }
    return sum;
}

Uses const since we only read the array, not modify it. The const keyword prevents accidental modifications. It also documents the function's intent to other programmers. The compiler will catch any attempts to change the array.

Function 2: Find Maximum Element

int findMax(const int arr[], int size) {
    if (size <= 0) return 0;  // Handle empty array
    
    int max = arr[0];
    for (int i = 1; i < size; i++) {
        if (arr[i] > max) {
            max = arr[i];
        }
    }
    return max;
}

Starts by assuming the first element is the maximum value. Then iterates through the remaining elements one by one. Each element is compared against the current maximum. If a larger value is found, it becomes the new maximum. This approach guarantees finding the true maximum in the array.

Function 3: Find Minimum Element

int findMin(const int arr[], int size) {
    if (size <= 0) return 0;
    
    int min = arr[0];
    for (int i = 1; i < size; i++) {
        if (arr[i] < min) {
            min = arr[i];
        }
    }
    return min;
}

Uses the same algorithm pattern as findMax function. Starts with the first element as the initial minimum. Compares each subsequent element against the current minimum. Updates the minimum when a smaller value is discovered. This mirror approach makes both functions easy to understand together.

Function 4: Calculate Average

double calculateAverage(const int arr[], int size) {
    if (size <= 0) return 0.0;
    return (double)sumArray(arr, size) / size;
}

Demonstrates code reuse by calling the existing sumArray() function. Divides the total sum by the array size to calculate the mean. Returns a double to preserve decimal precision in the result. Shows how functions can be composed to build more complex operations. This modular approach reduces code duplication and improves maintainability.

Using the Functions:

int main() {
    int scores[6] = {85, 92, 78, 95, 88, 76};
    int size = 6;
    
    printf("Sum: %d\n", sumArray(scores, size));       // 514
    printf("Max: %d\n", findMax(scores, size));        // 95
    printf("Min: %d\n", findMin(scores, size));        // 76
    printf("Average: %.2f\n", calculateAverage(scores, size)); // 85.67
    return 0;
}

Output:

Scores: 85 92 78 95 88 76

Sum: 514
Max: 95
Min: 76
Average: 85.67

Passing 2D Arrays

Two-dimensional arrays require special syntax. You must specify the column size in the function parameter because the compiler needs it to calculate element positions.

Define Constants for Array Dimensions

#define ROWS 3
#define COLS 4

Preprocessor constants define array dimensions in one place. Changes to ROWS or COLS automatically update all usages. Makes the code self-documenting and easier to understand. Prevents magic numbers scattered throughout the codebase. This is a best practice for any fixed-size array dimensions.

Function with arr[][COLS] Syntax

// For 2D arrays, column size MUST be specified
void print2DArray(int arr[][COLS], int rows) {
    for (int i = 0; i < rows; i++) {
        for (int j = 0; j < COLS; j++) {
            printf("%3d ", arr[i][j]);
        }
        printf("\n");
    }
}

The column size must be specified because C stores 2D arrays in row-major order. The compiler needs COLS to calculate memory offsets for element access. Row size can be omitted because only column stride matters for addressing. This is why arr[][COLS] syntax requires the second dimension. The compiler computes element address as: base + (row * COLS + col) * sizeof(int).

Alternative Pointer Syntax

// Alternative: use pointer to array
void print2DArrayAlt(int (*arr)[COLS], int rows) {
    for (int i = 0; i < rows; i++) {
        for (int j = 0; j < COLS; j++) {
            printf("%3d ", arr[i][j]);
        }
        printf("\n");
    }
}

The notation int (*arr)[COLS] reads as "pointer to array of COLS integers". Parentheses are crucial because int *arr[COLS] would mean array of pointers. Both syntaxes produce identical machine code when compiled. The pointer notation makes the type relationship more explicit. Choose whichever syntax is clearer for your team and codebase.

Using the Functions

int main() {
    int matrix[ROWS][COLS] = {
        {1, 2, 3, 4},
        {5, 6, 7, 8},
        {9, 10, 11, 12}
    };
    
    print2DArray(matrix, ROWS);
    print2DArrayAlt(matrix, ROWS);  // Same output
    return 0;
}

Output:

Using arr[][COLS] syntax:
  1   2   3   4
  5   6   7   8
  9  10  11  12

Using (*arr)[COLS] syntax:
  1   2   3   4
  5   6   7   8
  9  10  11  12

Passing Strings (Character Arrays)

In C, strings are character arrays ending with a null terminator (\0). They follow the same decay rules but have a special advantage: the null terminator marks the end, so you don't always need to pass the size.

Function 1: Print String Info

// String functions don't need size - they look for '\0'
void printString(const char str[]) {
    printf("String: %s\n", str);
    printf("Length: %zu characters\n", strlen(str));
}

The strlen() function from string.h returns the string length. It counts characters by scanning until it finds the null terminator. The null character itself is not included in the returned count. This is why strings don't need explicit size parameters passed. Always ensure strings are properly null-terminated before using strlen().

Function 2: Count Vowels

int countVowels(const char str[]) {
    int count = 0;
    for (int i = 0; str[i] != '\0'; i++) {
        char c = str[i];
        if (c == 'a' || c == 'e' || c == 'i' || c == 'o' || c == 'u' ||
            c == 'A' || c == 'E' || c == 'I' || c == 'O' || c == 'U') {
            count++;
        }
    }
    return count;
}

The loop continues as long as the current character is not null. The condition str[i] != '\0' automatically stops at string end. No size parameter is needed because strings are self-delimiting. This is a key advantage of null-terminated strings in C. Always use this pattern when iterating through strings character by character.

Function 3: Convert to Uppercase (Modifies Original)

void toUpperCase(char str[]) {  // No const - we modify it!
    for (int i = 0; str[i] != '\0'; i++) {
        if (str[i] >= 'a' && str[i] <= 'z') {
            str[i] = str[i] - 32;  // ASCII conversion
        }
    }
}

This function modifies the original string in place. Without const, the function is allowed to change array contents. The absence of const signals to callers that data will be modified. This is an important documentation practice in C programming. Always omit const when your function intentionally modifies parameters.

Using the Functions:

int main() {
    char message[] = "Hello, World!";
    
    printString(message);       // String: Hello, World!, Length: 13
    printf("Vowels: %d\n", countVowels(message));  // 3
    
    toUpperCase(message);
    printf("After uppercase: %s\n", message);  // HELLO, WORLD!
    return 0;
}

Output:

String: Hello, World!
Length: 13 characters
Vowels: 3

After uppercase: HELLO, WORLD!

Array Parameter Best Practices

C allows you to use modifiers like const and restrict with function parameters. These modifiers help you write safer and more efficient code by controlling how parameters are used inside functions.

Syntax:

// const - prevents modification (read-only)
void print_data(const int *ptr);        // cannot modify *ptr
void print_array(const int arr[], int n); // cannot modify arr elements

// restrict - optimization hint (C99)
void copy(int *restrict dest, const int *restrict src, int n);

// Combining modifiers
void process(const int *restrict data, int size);

The const Keyword in Detail

The const keyword is one of the most important tools for writing safe C code. It tells the compiler (and other programmers) that a value should not be modified.

Read-Only Function (with const):

// Function promises NOT to modify the array
void printArray(const int arr[], int size) {
    for (int i = 0; i < size; i++) {
        printf("%d ", arr[i]);
    }
    printf("\n");
    
    // This would cause a compiler error:
    // arr[0] = 999;  // Error: assignment of read-only location
}

The const keyword tells the compiler this data should not change. Any attempt to modify through this pointer causes a compile error. This catches accidental modification bugs at compile time, not runtime. The const promise also helps other programmers understand your intent. It's a form of documentation that the compiler actually enforces.

Modifying Function (without const):

// Function WILL modify the array (no const)
void doubleArray(int arr[], int size) {
    for (int i = 0; i < size; i++) {
        arr[i] *= 2;  // This is allowed
    }
}

Without the const qualifier, the function can freely modify elements. This signals to callers that their data may be changed. The absence of const is intentional and meaningful documentation. Use this when your function's purpose includes modifying the array. Readers can immediately tell this function has side effects on the data.

Using Both Functions:

int main() {
    int numbers[] = {1, 2, 3, 4, 5};
    int size = 5;
    
    printf("Original: ");
    printArray(numbers, size);
    
    doubleArray(numbers, size);
    
    printf("Doubled: ");
    printArray(numbers, size);
    return 0;
}

Output:

Original: 1 2 3 4 5
Doubled: 2 4 6 8 10

Understanding const with Pointers

With pointers, const can apply to the data being pointed to, the pointer itself, or both. The placement of const determines what is constant.

#include <stdio.h>

int main() {
    int x = 10, y = 20;
    
    // 1. Pointer to const: can't modify data through pointer
    const int *ptr1 = &x;
    // *ptr1 = 100;  // Error: assignment of read-only location
    ptr1 = &y;       // OK: can change where it points
    
    // 2. Const pointer: can't change where it points
    int *const ptr2 = &x;
    *ptr2 = 100;     // OK: can modify data
    // ptr2 = &y;    // Error: assignment of read-only variable
    
    // 3. Const pointer to const: can't do either
    const int *const ptr3 = &x;
    // *ptr3 = 100;  // Error: assignment of read-only location
    // ptr3 = &y;    // Error: assignment of read-only variable
    
    printf("x = %d\n", x);
    return 0;
}

Output:

x = 100

The restrict Keyword (C99)

The restrict keyword is a performance optimization hint for the compiler. It promises that the pointer is the only way to access that memory, allowing the compiler to generate more efficient code.

Without restrict (conservative compilation):

// Compiler must assume src and dest might overlap
void copyArraySlow(int *dest, const int *src, int n) {
    for (int i = 0; i < n; i++) {
        dest[i] = src[i];
    }
}

Without restrict, the compiler must assume pointers might overlap. This forces conservative code generation with extra memory loads. The compiler can't cache values because another pointer might change them. Loop optimizations like vectorization may be disabled for safety. This is correct but potentially slower than optimized code.

With restrict (optimized compilation):

// Compiler knows they don't overlap, can optimize
void copyArrayFast(int *restrict dest, const int *restrict src, int n) {
    for (int i = 0; i < n; i++) {
        dest[i] = src[i];
    }
}

The restrict keyword promises these pointers don't alias each other. The compiler can now assume no overlap between src and dest. This enables aggressive optimizations like SIMD vectorization. Loop iterations can be processed in parallel for better performance. Only use restrict when you can guarantee the pointers don't overlap.

Usage Example:

int main() {
    int source[] = {1, 2, 3, 4, 5};
    int destination[5];
    
    copyArrayFast(destination, source, 5);
    
    // Prints: Copied: 1 2 3 4 5
    return 0;
}

Real-World Examples of Parameter Modifiers

The C standard library uses these modifiers extensively. Understanding them helps you read and use library functions correctly.

// From string.h - notice the modifier patterns

// strlen: only reads the string, uses const
size_t strlen(const char *s);

// strcpy: dest is modified, src is read-only, both use restrict
char *strcpy(char *restrict dest, const char *restrict src);

// memcpy: same pattern as strcpy
void *memcpy(void *restrict dest, const void *restrict src, size_t n);

// strcmp: compares two strings, neither modified
int strcmp(const char *s1, const char *s2);

// qsort: compare function uses const void pointers
void qsort(void *base, size_t nmemb, size_t size,
           int (*compar)(const void *, const void *));

Combining Multiple Modifiers

For maximum safety and performance, you can combine modifiers. This is common in high-performance code.

Example 1: Processing Arrays with restrict and const

// Read-only input, modifiable output, no overlap guaranteed
void processData(int *restrict output, 
                 const int *restrict input, 
                 int size, 
                 int multiplier) {
    for (int i = 0; i < size; i++) {
        output[i] = input[i] * multiplier;
    }
}

The const modifier ensures the input array remains unchanged. The restrict modifier promises no overlap between input and output. Together, they provide both safety guarantees and optimization hints. This pattern is common in high-performance data processing code. Standard library functions like memcpy use this exact combination.

Example 2: Maximum Protection with const pointer to const data

// Neither the data nor the pointer can be modified
void analyzeData(const int *const data, int size) {
    int sum = 0;
    for (int i = 0; i < size; i++) {
        sum += data[i];
    }
    printf("Sum: %d, Average: %.2f\n", sum, (double)sum / size);
}

The first const (const int*) prevents modifying the pointed-to data. The second const (*const) prevents changing where the pointer points. This provides maximum protection for read-only analysis functions. Neither the array elements nor the pointer itself can be changed. Use this pattern when the function should be purely observational.

Using the Functions:

int main() {
    int source[] = {1, 2, 3, 4, 5};
    int result[5];
    
    processData(result, source, 5, 3);  // Multiply each by 3
    analyzeData(result, 5);             // Analyze the result
    return 0;
}
// Output: Sum: 45, Average: 9.00

Output:

Result: 3 6 9 12 15
Sum: 45, Average: 9.00

When to Use Each Modifier