Function pointer as argument in C

Passing pointers as function arguments in C allows you to work directly with the data at a particular memory location, making it a powerful feature for functions that need to modify data or operate on large data structures efficiently.

When to pass pointers as arguments

You should pass pointers as arguments to functions when you want to:

  1. Allow the function to modify the value of the argument directly.
  2. Avoid passing large amounts of data to the function.
  3. Make your code more modular and reusable.

Passing Pointers to Modify Data

You can pass a pointer to a function when you want the function to modify the original data. This allows the function to work directly with the caller's data in memory.

#include <stdio.h> void modifyValue(int *ptr) { *ptr = 999; // Modify the value pointed to by 'ptr' } int main() { int num = 55; printf("Before function call: %d\n", num); // Pass a pointer to 'num' to modify its value modifyValue(&num); printf("After function call: %d\n", num); return 0; }
//Output: Before function call: 55 After function call: 999

In the above example, we pass a pointer to an integer (&num) to the modifyValue function, which directly modifies the value of num.

Passing Pointers for Efficiency

When dealing with large data structures, it's more efficient to pass a pointer to the data rather than copying the entire structure. This can improve program performance and save memory.

#include <stdio.h> // Structure representing a point in 2D space struct Point { int x; int y; }; // Function to print the coordinates of a point void printPoint(const struct Point *point) { printf("X: %d, Y: %d\n", point->x, point->y); } int main() { // Create a Point structure struct Point p = {10, 20}; // Pass a pointer to the Point structure for printing printPoint(&p); return 0; }
//Output: X: 10, Y: 20

In this example, we define a Point structure and pass a pointer to a Point structure to the printPoint function to avoid copying the entire structure.

Passing Arrays as Pointers

Arrays are passed to functions as pointers to their first element. You can use pointers to access and modify elements of the original array.

#include <stdio.h> // Function to compute the sum of an array of integers int sumArray(const int *arr, int size) { int sum = 0; for (int i = 0; i < size; i++) { sum += arr[i]; // Access elements using pointer arithmetic } return sum; } int main() { int numbers[] = {10, 20, 30, 40, 50}; int size = sizeof(numbers) / sizeof(numbers[0]); int total = sumArray(numbers, size); printf("Sum of the array: %d\n", total); return 0; }
//Output: Sum of the array: 150

Here, the sumArray function takes a pointer to an integer array and its size as arguments, allowing it to compute the sum of the array's elements without making a copy of the array.

Advantages of passing pointers as function arguments

There are several advantages to passing pointers as function arguments:

  1. Efficiency: Passing pointers instead of values can improve the efficiency of your code by reducing the amount of data that needs to be copied between the function and the caller.
  2. Flexibility: Passing pointers allows the function to modify the values of the arguments directly. This can be useful for functions that need to perform complex operations on the data.
  3. Modularity: Passing pointers makes your code more modular and reusable. By passing pointers to functions, you can encapsulate the data and logic of the function, which makes it easier to use and maintain.


Passing pointers as function arguments is a fundamental concept in C that allows for efficient memory usage and the ability to manipulate data directly, especially in scenarios involving large data structures or when modifying data in the caller's context. However, it also requires careful handling to prevent unintended changes to memory.