When you pass an array to a function, C passes the memory address of the first element (pointer), not a copy of the entire array. The function can modify the original array.
Basic Syntax
// Method 1: Using array syntax returnType functionName(type arrayName[], int size); // Method 2: Using pointer syntax returnType functionName(type *arrayName, int size);
Both methods are identical. The array "decays" to a pointer.
Example 1: Print Array Elements
#include <stdio.h>
// Receives array as parameter
void printArray(int arr[], int size) {
for(int i = 0; i < size; i++) {
printf("%d ", arr[i]);
}
printf("\n");
}
int main() {
int numbers[] = {10, 20, 30, 40, 50};
int size = sizeof(numbers) / sizeof(numbers[0]);
printArray(numbers, size); // Pass array name (address)
return 0;
}
Output:
10 20 30 40 50
Example 2: Modify Array Inside Function
#include <stdio.h>
// Function modifies the original array
void doubleValues(int arr[], int size) {
for(int i = 0; i < size; i++) {
arr[i] = arr[i] * 2; // Changes reflect in main
}
}
void printArray(int arr[], int size) {
for(int i = 0; i < size; i++) {
printf("%d ", arr[i]);
}
printf("\n");
}
int main() {
int numbers[] = {1, 2, 3, 4, 5};
int size = 5;
printf("Before: ");
printArray(numbers, size);
doubleValues(numbers, size);
printf("After: ");
printArray(numbers, size);
return 0;
}
Output:
Before: 1 2 3 4 5 After: 2 4 6 8 10
Example 3: Calculate Sum (Returning Value)
#include <stdio.h>
int calculateSum(int arr[], int size) {
int sum = 0;
for(int i = 0; i < size; i++) {
sum += arr[i];
}
return sum;
}
float calculateAverage(int arr[], int size) {
int sum = calculateSum(arr, size);
return (float)sum / size;
}
int main() {
int scores[] = {85, 90, 78, 92, 88};
int size = 5;
int total = calculateSum(scores, size);
float avg = calculateAverage(scores, size);
printf("Sum: %d\n", total);
printf("Average: %.2f\n", avg);
return 0;
}
Output:
Sum: 433 Average: 86.60
Example 4: Find Max and Min
#include <stdio.h>
int findMax(int arr[], int size) {
int max = arr[0];
for(int i = 1; i < size; i++) {
if(arr[i] > max) {
max = arr[i];
}
}
return max;
}
int findMin(int arr[], int size) {
int min = arr[0];
for(int i = 1; i < size; i++) {
if(arr[i] < min) {
min = arr[i];
}
}
return min;
}
int main() {
int numbers[] = {45, 12, 89, 34, 67, 23, 99, 11};
int size = sizeof(numbers) / sizeof(numbers[0]);
printf("Maximum: %d\n", findMax(numbers, size));
printf("Minimum: %d\n", findMin(numbers, size));
return 0;
}
Output:
Maximum: 99 Minimum: 11
Example 5: Passing Array with Pointer Syntax
#include <stdio.h>
// Using pointer syntax (same as array syntax)
void reverseArray(int *arr, int size) {
for(int i = 0; i < size / 2; i++) {
int temp = arr[i];
arr[i] = arr[size - 1 - i];
arr[size - 1 - i] = temp;
}
}
void printArray(int *arr, int size) {
for(int i = 0; i < size; i++) {
printf("%d ", arr[i]); // Can use arr[i] or *(arr+i)
}
printf("\n");
}
int main() {
int arr[] = {1, 2, 3, 4, 5, 6};
int size = 6;
printf("Original: ");
printArray(arr, size);
reverseArray(arr, size);
printf("Reversed: ");
printArray(arr, size);
return 0;
}
Output:
Original: 1 2 3 4 5 6 Reversed: 6 5 4 3 2 1
Example 6: Passing 2D Array
#include <stdio.h>
// For 2D arrays, must specify column size
void printMatrix(int rows, int cols, int matrix[][3]) {
for(int i = 0; i < rows; i++) {
for(int j = 0; j < cols; j++) {
printf("%3d ", matrix[i][j]);
}
printf("\n");
}
}
void multiplyByScalar(int rows, int cols, int matrix[][3], int scalar) {
for(int i = 0; i < rows; i++) {
for(int j = 0; j < cols; j++) {
matrix[i][j] *= scalar;
}
}
}
int main() {
int matrix[2][3] = {
{1, 2, 3},
{4, 5, 6}
};
printf("Original matrix:\n");
printMatrix(2, 3, matrix);
multiplyByScalar(2, 3, matrix, 2);
printf("\nAfter multiplying by 2:\n");
printMatrix(2, 3, matrix);
return 0;
}
Output:
Original matrix: 1 2 3 4 5 6 After multiplying by 2: 2 4 6 8 10 12
Size Matters: Passing Size Separately
#include <stdio.h>
// You CANNOT get size inside function like this:
void badFunction(int arr[]) {
// sizeof(arr) returns pointer size (8 bytes), NOT array size!
int size = sizeof(arr) / sizeof(arr[0]); // WRONG!
printf("Inside function size: %lu\n", sizeof(arr));
}
// Always pass size as separate parameter
void goodFunction(int arr[], int size) {
printf("Array elements: ");
for(int i = 0; i < size; i++) {
printf("%d ", arr[i]);
}
printf("\n");
}
int main() {
int numbers[] = {10, 20, 30, 40, 50};
int size = sizeof(numbers) / sizeof(numbers[0]);
printf("In main, array size: %lu bytes\n", sizeof(numbers));
printf("In main, number of elements: %d\n", size);
badFunction(numbers);
goodFunction(numbers, size);
return 0;
}
Output:
In main, array size: 20 bytes In main, number of elements: 5 Inside function size: 8 Array elements: 10 20 30 40 50
Comparison Table
| Passing Method | Syntax | Modifies Original? | Size Info |
|---|---|---|---|
| Array syntax | func(int arr[], int size) | Yes | Needs separate param |
| Pointer syntax | func(int *arr, int size) | Yes | Needs separate param |
| Fixed size array | func(int arr[10]) | Yes | Fixed, but only first dimension |
| 2D array | func(int arr[][col], int col) | Yes | Column size required |
Key Rules
| Rule | Explanation |
|---|---|
| Arrays are passed by reference | Function receives address, not copy |
| Original array gets modified | Changes inside function affect original |
| Size is lost | Always pass size as separate parameter |
| Square brackets vs pointer | int arr[] = int *arr (identical) |
| 2D arrays need column size | func(int arr[][5]) or func(int (*arr)[5]) |
Common Mistakes
// ❌ WRONG - Forgetting size parameter
void printArray(int arr[]) {
// Cannot know how big arr is
}
// ✅ CORRECT - Always pass size
void printArray(int arr[], int size) {
for(int i = 0; i < size; i++)
printf("%d ", arr[i]);
}
// ❌ WRONG - Trying to return local array
int* badFunction() {
int arr[] = {1, 2, 3};
return arr; // arr dies after function ends
}
// ✅ CORRECT - Modify array passed as parameter
void goodFunction(int arr[], int size) {
// Modify arr directly
arr[0] = 100;
}
Quick Summary
| Operation | Code | Notes |
|---|---|---|
| Pass 1D array | func(arr, size) | Pass name and size |
| Receive 1D array | void func(int arr[], int size) | Use empty brackets |
| Pass 2D array | func(matrix, rows, cols) | Pass with dimensions |
| Receive 2D array | void func(int mat[][cols], int rows, int cols) | Specify column size |
| Array decays to pointer | int *arr = int arr[] | Both are equivalent |
| Can't get size inside | Use sizeof(arr) in main only | Pass as parameter |
Complete Guide to Core & Advanced C Programming Concepts (Functions, Strings, Arrays, Loops, I/O, Control Flow)
https://macronepal.com/bash/building-blocks-of-c-a-complete-guide-to-functions/
Explains how functions in C work as reusable blocks of code, including declaration, definition, parameters, return values, and modular programming structure.
https://macronepal.com/bash/the-heart-of-text-processing-a-complete-guide-to-strings-in-c-2/
Explains how strings are handled in C using character arrays, string manipulation techniques, and common library functions for text processing.
https://macronepal.com/bash/the-cornerstone-of-data-organization-a-complete-guide-to-arrays-in-c/
Explains arrays in C as structured memory storage for multiple values, including indexing, initialization, and efficient data organization.
https://macronepal.com/bash/guaranteed-execution-a-complete-guide-to-the-do-while-loop-in-c/
Explains the do-while loop in C, where the loop body executes at least once before checking the condition.
https://macronepal.com/bash/mastering-iteration-a-complete-guide-to-the-for-loop-in-c/
Explains the for loop in C, including initialization, condition checking, and increment/decrement for controlled iteration.
https://macronepal.com/bash/mastering-iteration-a-complete-guide-to-while-loops-in-c/
Explains the while loop in C, focusing on condition-based repetition and proper loop control mechanisms.
https://macronepal.com/bash/beyond-if-else-a-complete-guide-to-switch-case-in-c/
Explains switch-case statements in C, enabling multi-branch decision-making based on variable values.
https://macronepal.com/bash/mastering-conditional-logic-a-complete-guide-to-if-else-statements-in-c/
Explains if-else statements in C for decision-making and controlling program flow based on conditions.
https://macronepal.com/bash/mastering-the-fundamentals-a-complete-guide-to-arithmetic-operations-in-c/
Explains arithmetic operations in C such as addition, subtraction, multiplication, division, and operator precedence.
https://macronepal.com/bash/foundation-of-c-programming-a-complete-guide-to-basic-input-output/
Explains basic input and output in C using scanf and printf for interacting with users and displaying results.
Online C Code Compiler
https://macronepal.com/free-online-c-code-compiler-2/