🧩 12. Functions in C

Functions are one of the most important building blocks of C programming. They allow us to divide a large program into smaller, meaningful and reusable pieces of code.

12.1 What Is a Function?

A function is a block of statements that performs a specific operation. It can receive input through parameters and can optionally return a result.

#include <stdio.h>

void greet(void)
{
    printf("Hello, CodeBhavya!\n");
}

int main(void)
{
    greet();

    return 0;
}

Here, greet() is a user-defined function. When greet() is called, the statements inside its body execute.

12.2 Why Do We Need Functions?

Imagine a program that contains 2,000 lines of code. If all of those statements are written inside main(), the program becomes difficult to read, test and maintain.

Functions allow us to divide the program according to responsibilities.

main()
{
    input code
    calculation code
    validation code
    display code
    another calculation
    another validation
    another display
}

main()
{
    readData();
    calculateResult();
    validateResult();
    displayResult();
}

12.3 Anatomy of a Function

return_type function_name(parameter_list)
{
    // function body
    statements;

    return value;
}

A function can be understood through four major parts:

12.4 Function Declaration

A function declaration tells the compiler about a function before the function is used.

int add(int a, int b);

This tells the compiler that a function named add:

• returns an int
• expects two int parameters
• will be defined somewhere in the program

12.5 Function Definition

The function definition contains the actual implementation.

int add(int a, int b)
{
    return a + b;
}

The definition tells the compiler what the function actually does.

12.6 Calling a Function

A function does not execute merely because it has been defined. It executes when it is called.

#include <stdio.h>

void message(void)
{
    printf("Welcome to C Programming!\n");
}

int main(void)
{
    message();

    return 0;
}

The statement:

message();

is the function call.

main()
   |
   | calls
   v
message()
   |
   | executes printf()
   v
returns to main()
   |
   v
return 0

12.7 Parameters and Arguments

Functions can receive data from the caller. The variables listed in the function definition are called parameters. The actual values supplied during the call are called arguments.

int add(int a, int b)
{
    return a + b;
}

int result = add(10, 20);

12.8 Returning a Value

A function can calculate a result and send that result back to its caller using the return statement.

int square(int n)
{
    return n * n;
}

int main(void)
{
    int result;

    result = square(5);

    printf("%d\n", result);

    return 0;
}

Execution:

square(5)
    |
    | n = 5
    |
    | 5 * 5
    v
return 25
    |
    v
result = 25

12.9 Functions That Return Nothing — void

If a function does not return a value, its return type can be void.

void display(void)
{
    printf("Hello!\n");
}

The first void means the function returns no value. The second void means it accepts no parameters.

void display(void);

12.10 Functions with Multiple Parameters

A function can receive multiple parameters.

int multiply(int a, int b, int c)
{
    return a * b * c;
}

int main(void)
{
    int result = multiply(2, 3, 4);

    printf("%d\n", result);

    return 0;
}

The values are matched with parameters according to their position:

multiply(2, 3, 4)

a = 2
b = 3
c = 4

12.11 Why Do We Need a Function Prototype?

Suppose the function is defined after main(). The compiler needs to know about the function before encountering the call.

#include <stdio.h>

int add(int a, int b);

int main(void)
{
    int result = add(10, 20);

    printf("%d\n", result);

    return 0;
}

int add(int a, int b)
{
    return a + b;
}

The prototype:

int add(int a, int b);

provides the necessary information before the call.

Prototype
    |
    v
Compiler knows function signature
    |
    v
main() calls add()
    |
    v
add() definition appears later
    |
    v
Function executes

12.12 Defining a Function Before main()

A function can also be completely defined before main(). In that case, the compiler has already seen the definition when it encounters the call.

#include <stdio.h>

int add(int a, int b)
{
    return a + b;
}

int main(void)
{
    printf("%d\n", add(5, 7));

    return 0;
}

12.13 Four Common Function Forms (Categories of User-Defined Functions)

A useful beginner classification is based on whether a function receives arguments and whether it returns a value. There are four categories when we combine these two choices: input through arguments (yes/no) and output through a return value (yes/no).

Does it receive arguments?
                       /                  \
                     NO                    YES
                     |                      |
            Does it return data?     Does it return data?
               /         \            /         \
             NO          YES          NO          YES
             |            |           |            |
           Type 1       Type 3      Type 2       Type 4

Important distinction: A function may display information with printf() without returning a value to the calling function. In these examples, void before the name means there is no return value; void inside the parentheses means the function accepts no arguments.

Category 1 — No arguments and no return value

The function receives no data from the caller and does not send a result back using return. It performs its task internally, such as displaying a message.

Complete C program:

#include <stdio.h>

/* No arguments and no return value */
void greet(void)
{
    printf("Welcome to CodeBhavya!\n");
}

int main(void)
{
    greet();
    return 0;
}

Output:

Welcome to CodeBhavya!

Category 2 — With arguments and no return value

The calling function supplies one or more values. The called function uses those values to perform an action, but it does not return a result to the caller.

Complete C program:

#include <stdio.h>

/* Arguments but no return value */
void printSquare(int number)
{
    printf("Square = %d\n", number * number);
}

int main(void)
{
    printSquare(5);
    return 0;
}

Output:

Square = 25

Category 3 — No arguments but returns a value

The function does not need any input from the caller. It calculates, retrieves, or supplies a value, and returns that value to the calling function.

Complete C program:

#include <stdio.h>

/* No arguments but a return value */
int getNumber(void)
{
    return 42;
}

int main(void)
{
    int value = getNumber();
    printf("Number = %d\n", value);
    return 0;
}

Output:

Number = 42

Category 4 — With arguments and a return value

The calling function passes input values; the called function processes those values and sends the computed result back. This form is especially useful for reusable calculations.

Complete C program:

#include <stdio.h>

/* Arguments and a return value */
int add(int a, int b)
{
    return a + b;
}

int main(void)
{
    int sum = add(10, 20);
    printf("Sum = %d\n", sum);
    return 0;
}

Output:

Sum = 30

How to identify the category from a function header

Self-check

Identify the category of each function below and check your reasoning.

1. void show(int age) — arguments, but no return value: Category 2.
2. int readChoice(void) — no arguments, returns a value: Category 3.
3. float area(float radius) — arguments and returns a value: Category 4.
4. void welcome(void) — no arguments, no return value: Category 1.

12.14 Library Functions vs User-Defined Functions

For example, printf() is a library function provided through the standard I/O facilities, while add() in the following program is user-defined.

int add(int a, int b)
{
    return a + b;
}

12.15 C Uses Pass-by-Value

C passes function arguments by value. That means the function receives a value for its parameter. Changing that parameter does not directly change the caller's ordinary variable.

#include <stdio.h>

void change(int x)
{
    x = 100;
}

int main(void)
{
    int n = 10;

    change(n);

    printf("%d\n", n);

    return 0;
}

Output:

10

main()

n = 10
 |
 | value copied
 v
change()

x = 10
 |
 | x = 100
 v
x = 100

Back in main:

n is still 10

12.16 Call by Reference (Using Pointers in C)

In many textbooks, call by reference means allowing a function to modify the original variable in the calling function. In C, we achieve this effect by passing the address of the variable to a function using a pointer parameter.

Syntax and the two important operators

void change(int *p);  /* p is a pointer parameter */
change(&number);      /* & passes the address of number */
*p = 100;             /* * accesses the value at that address */

& is the address-of operator, while * dereferences a pointer to access or modify the value stored at its address.

Complete C program — Modifying the original value

#include <stdio.h>

void change(int *x)
{
    *x = 100;
}

int main(void)
{
    int n = 10;

    printf("Before function call: %d\n", n);
    change(&n);
    printf("After function call: %d\n", n);

    return 0;
}

Output:

Before function call: 10
After function call: 100

main()                          change(int *x)

n = 10  <--- address of n ---  x points to n
  |                                |
  +------------ *x = 100 ----------+
  |
n = 100 (the original variable changed)

Call by value vs call by reference (using pointers)

Self-check

What will be printed after change(&n) if change() executes *x = 100; and n originally contains 10? Answer: 100, because the function updates the original memory location.

12.17 Local Variables Inside Functions

A variable declared inside a function normally has block scope and can be accessed only within the appropriate block.

void calculate(void)
{
    int total = 50;

    printf("%d\n", total);
}

The variable total is local to the function.

void calculate(void)
{
    int total = 50;
}

int main(void)
{
    printf("%d", total);   /* Error */
}

12.18 Functions and Global Variables

A variable defined outside functions can have file scope and may be accessible to functions in the same source file according to its declaration and linkage.

#include <stdio.h>

int count = 10;

void display(void)
{
    printf("%d\n", count);
}

int main(void)
{
    display();

    return 0;
}

12.19 Passing an Array to a Function

Arrays are frequently processed using functions. When an array is passed to a function, the parameter is adjusted to a pointer to its first element.

#include <stdio.h>

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

int main(void)
{
    int numbers[] = {10, 20, 30, 40};

    display(numbers, 4);

    return 0;
}

12.20 Passing Strings to Functions

A C string is stored in a character array ending with the null character '\0'. A string can be passed to a function using a character pointer or an array parameter.

#include <stdio.h>

void displayString(const char text[])
{
    printf("%s\n", text);
}

int main(void)
{
    char name[] = "CodeBhavya";

    displayString(name);

    return 0;
}

The const qualifier communicates that the function does not intend to modify the characters through that parameter.

12.21 Functions and Pointers — Preview

Pointers allow a function to work with the address of an object. This is how a function can modify a variable belonging to its caller.

#include <stdio.h>

void change(int *x)
{
    *x = 100;
}

int main(void)
{
    int n = 10;

    change(&n);

    printf("%d\n", n);

    return 0;
}

Here:

&n   → address of n
*x   → value stored at that address

12.22 Recursion

Recursion occurs when a function calls itself.

void countDown(int n)
{
    if (n == 0)
    {
        return;
    }

    printf("%d\n", n);

    countDown(n - 1);
}

A recursive function normally needs two important parts:

12.23 Program Tracing — Recursive Function

Consider:

void countDown(int n)
{
    if (n == 0)
        return;

    printf("%d ", n);

    countDown(n - 1);
}

Suppose:

countDown(3);

The execution can be visualized as:

countDown(3)
    |
    | print 3
    v
countDown(2)
    |
    | print 2
    v
countDown(1)
    |
    | print 1
    v
countDown(0)
    |
    | base case
    v
return

Output:
3 2 1

12.24 Function Calls and the Call Stack

When a function is called, the program needs to keep track of the function's execution state, parameters and local information. This is commonly represented using the call stack.

main()
  |
  +--> calculate()
          |
          +--> square()
                  |
                  +--> return
          |
          +--> return
  |
  +--> return

TOP
┌──────────────────────┐
│ square()             │
├──────────────────────┤
│ calculate()          │
├──────────────────────┤
│ main()               │
└──────────────────────┘
BOTTOM

When square() returns, its active call is removed and execution continues in calculate().

12.25 One Function Can Call Another Function

#include <stdio.h>

int square(int n)
{
    return n * n;
}

int doubleValue(int n)
{
    return 2 * n;
}

int main(void)
{
    int value = square(doubleValue(3));

    printf("%d\n", value);

    return 0;
}

Trace the calls from the inside:

doubleValue(3)
    ↓
6

square(6)
    ↓
36

value = 36

12.26 Designing Good Functions

A good function generally has a clear responsibility.

Input
  ↓
Validation
  ↓
Calculation
  ↓
Output

12.27 Common Mistakes

1. Calling a function with the wrong number of arguments

int add(int a, int b);

add(10);       /* Wrong */
add(10, 20);   /* Correct */

2. Forgetting the return statement

int square(int n)
{
    n * n;      /* Does not return the result */
}

Correct:

int square(int n)
{
    return n * n;
}

3. Returning a value from a void function

void display(void)
{
    return 10;      /* Wrong */
}

4. Using a local variable outside its scope

void test(void)
{
    int x = 10;
}

int main(void)
{
    printf("%d", x);    /* Wrong */
}

5. Infinite recursion

void test(void)
{
    test();
}

There is no terminating condition.

6. Modifying a variable incorrectly through a value parameter

void change(int x)
{
    x = 100;
}

This does not modify the caller's ordinary variable.

12.28 Common Confusions

int add(int, int);     /* declaration */

add(10, 20);           /* call */

int add(int a, int b)
{
    return a + b;
}

add(5, 7);

int square(int n)
{
    return n * n;
}

void display(void)

12.29 Complete Program Analysis

#include <stdio.h>

int calculateSquare(int n);

int main(void)
{
    int number;
    int result;

    printf("Enter a number: ");
    scanf("%d", &number);

    result = calculateSquare(number);

    printf("Square = %d\n", result);

    return 0;
}

int calculateSquare(int n)
{
    return n * n;
}

Execution flow

1. Program starts
       ↓
2. main() begins
       ↓
3. number is declared
       ↓
4. Input is read
       ↓
5. calculateSquare(number) is called
       ↓
6. value is copied into n
       ↓
7. n * n is calculated
       ↓
8. result is returned
       ↓
9. result receives returned value
       ↓
10. printf() displays result
       ↓
11. return 0
       ↓
12. Program ends

12.30 Important Interview Point: Array Parameter

Consider:

void display(int arr[])

For a function parameter, an array parameter is adjusted to a pointer parameter. Therefore, these forms are equivalent for parameter purposes:

void display(int arr[]);
void display(int *arr);

The array's size is therefore commonly passed separately:

void display(int arr[], int size)