Example: Pass Pointers to Functions

Why This Matters

In C programming, passing pointers to functions can be a powerful tool for improving code efficiency and flexibility. By understanding how to pass pointers, you'll be able to write more versatile functions that can accept and manipulate data of various types. This skill is essential for tackling real-world coding challenges and acing interviews.

Prerequisites

Before diving into passing pointers to functions, it's important to have a solid understanding of the following topics:

1. Data types in C
2. Arrays in C
3. Pointers in C (relationship between arrays and pointers)
4. Function definitions and calling functions

Core Concept

To pass a pointer to a function, we first need to understand what a pointer is: a variable that stores the memory address of another variable. In our case, we'll be passing the memory addresses of variables or arrays to functions so they can manipulate them directly.

Let's start with a simple example where we pass a pointer to a function that increments the value of an integer.

#include <stdio.h>

void increment(int *ptr) {
(*ptr)++; // dereferencing the pointer to access and modify the stored value
}

int main() {
int num = 5;
printf("Initial number: %d\n", num);
increment(&num);
printf("Number after incrementing: %d\n", num);
return 0;
}

In this example, we define a function called increment() that takes an integer pointer as its argument. Inside the function, we dereference the pointer using the indirection operator (*) to access and modify the value stored at the memory address pointed by ptr. In the main function, we create an integer variable num, call the increment() function with the address of num (obtained using the address-of operator &), and print the initial and modified values of num.

Worked Example

Let's consider a more complex example where we pass pointers to a function that swaps two integers without using temporary variables.

#include <stdio.h>

void swap(int *a, int *b) {
int temp = *a; // store the value at memory address pointed by 'a' in a temporary variable
*a = *b; // assign the value at memory address pointed by 'b' to the memory address pointed by 'a'
*b = temp; // assign the stored value back to the memory address pointed by 'b'
}

int main() {
int num1 = 3, num2 = 5;
printf("Before swapping: num1 = %d, num2 = %d\n", num1, num2);
swap(&num1, &num2);
printf("After swapping: num1 = %d, num2 = %d\n", num1, num2);
return 0;
}

In this example, we define a function called swap() that takes two integer pointers as arguments. Inside the function, we swap the values stored at the memory addresses pointed by a and b using a temporary variable (temp) to hold the initial value of *a. This method allows us to achieve swapping without requiring extra memory for storing temporary variables.

Common Mistakes

1. Forgetting the indirection operator: When working with pointers, always remember to dereference them using the indirection operator (*) to access and modify the values they point to.

// Incorrect: incrementing a pointer instead of the value it points to
void increment(int *ptr) {
ptr++; // moving the pointer to the next memory address
}

1. Not passing pointers correctly: When calling functions with pointers as arguments, always pass the addresses of variables using the address-of operator (&).

// Incorrect: not passing the address of num1
void increment(int num) {
num++; // this will modify the local variable 'num' in the function scope
}

int main() {
int num1 = 5;
increment(num1); // incorrect call to the function
printf("Modified number: %d\n", num1); // the number remains unchanged
}

1. Confusing pointers and arrays: Remember that arrays decay into pointers in C, so when you pass an array as a function argument, it's treated as a pointer to its first element.

// Incorrect: assuming 'arr' is a two-dimensional array
void printArray(int arr[2][2]) {
// ...
}

int main() {
int arr[2][2] = {{1, 2}, {3, 4}};
printArray(arr); // incorrect call to the function
}

In this example, printArray() expects a two-dimensional array as its argument, but we pass a one-dimensional array (a pointer to the first element of a two-dimensional array). To fix this issue, we should declare the function to accept a pointer to an array:

void printArray(int (*arr)[2]) {
// ...
}

int main() {
int arr[2][2] = {{1, 2}, {3, 4}};
printArray(&arr); // correct call to the function
}

Practice Questions

1. Write a function that takes two pointers to integers and returns their sum without using temporary variables.

int sum(int *a, int *b) {
return *a + *b;
}

int main() {
int num1 = 3, num2 = 5;
printf("Sum: %d\n", sum(&num1, &num2));
return 0;
}

1. Write a function that swaps two strings using pointers without copying their contents.

#include <string.h>

void swapStrings(char *str1, char *str2) {
size_t len1 = strlen(str1);
size_t len2 = strlen(str2);

char temp[len1 + len2]; // create a temporary buffer to store the concatenated strings
strcpy(temp, str1); // copy string 1 into the temporary buffer
strcat(temp, str2); // append string 2 to the temporary buffer

// replace the original strings with their swapped order
strcpy(str1, str2);
strcpy(str2, temp);
}

int main() {
char str1[30] = "Hello";
char str2[30] = "World";
printf("Before swapping: %s, %s\n", str1, str2);
swapStrings(str1, str2);
printf("After swapping: %s, %s\n", str1, str2);
return 0;
}

FAQ

Why do we pass pointers to functions instead of passing values?

Passing pointers to functions can improve code efficiency by reducing the amount of memory required for function calls. When we pass a large data structure like an array or a struct, copying its entire contents into the function would consume unnecessary memory and time. By passing pointers, we allow the function to manipulate the original data directly without having to create copies.

What happens when we pass the address of a local variable to a function?

When we pass the address of a local variable to a function, its value is still stored on the stack within the function's scope. However, once the function returns, the local variable gets destroyed, and the memory it occupied becomes available for reuse. If the function modifies the value of the local variable through the pointer, that modification will be lost when the variable goes out of scope.

How can we pass a two-dimensional array to a function in C?

To pass a two-dimensional array as an argument to a function in C, you should declare the function to accept a pointer to an array (one-dimensional array) and then use it appropriately within the function. For example:

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

int main() {
int arr[2][2] = {{1, 2}, {3, 4}};
printArray(arr); // correct call to the function
return 0;
}