C Basics

Mastering C Functions: Syntax, Recursion and 2 Types of Function

What Is a Function in C?

Functions in C group related instructions into a single block to solve a specific problem. Instead of writing the same logic repeatedly, you write it once inside a function and call it whenever needed.

Basic syntax of a C function:

return_type function_name(parameter_list) {
    // function body
}

Why Functions Are Essential in C

Functions are not optional design choices but they are essential for real-world C programming.

Advantages:

Code reusability: write once, use many times
Better readability: smaller, meaningful blocks
Easy debugging: isolate errors faster
Modularity: divide large programs into manageable parts
Team collaboration: different developers handle different functions.

Without functions, C programs become long, unreadable and error-prone.

Types of Functions in C

There are two types of functions in C

1. Library Functions

These are predefined functions provided by C standard libraries.

Examples:

printf() – output
scanf() – input
strlen() – string length
sqrt() – square root

2. User-Defined Functions: Functions written by the programmer to solve specific problems.

Consider a simple function below to print “Hello World.”

#include 
void greet() {
    printf("Welcome to Qubrica!");
}
int main() {
    greet();
    return 0;       // Welcome to Qubrica!
}

Function Declaration, Definition and Call

Understanding these three steps is critical.

1. Function Declaration (The Blueprint): Tells the compiler about the function before it’s used. Parameter names are optional here, only types are required.

int add(int, int);

2. Function Definition: The actual logic. This is where the code lives and memory is allocated.

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

3. Function Call: Pauses the current code (like main) to jump to the function and execute it.

int result = add(5, 10);

Check the full code below

#include 
int add(int, int);
int main() {
         // 2. CALL (The Execution)
    int sum = add(5, 10);
    printf("Sum: %d", sum);
    return 0;
}
// 3. The Actual logic
int add(int a, int b) {
    return a + b;
}

// Sum: 15

Return Types in C Functions

The Return Type tells the computer what kind of data (if any) the function will send back after it finishes its job. A function may or may not return a value.

1. Function with return value: This function does a calculation and gives you back a result. You usually store this result in a variable to use later. It must end with a return Statement.

Write a c program to print the square of a number by using a function with a return value

				
					#include <stdio.h>
int square(int x) {
    return x * x;    // Sends the result back
}
int main() {
    int number = 5;
    int result = square(number);
    printf("The square of %d is %d", number, result);
    return 0;
}

// The square of 5 is 25

2. Function without Return Value: This function performs an action (like printing text, saving a file or beeping) but it gives nothing back to the program. It need not end with a return statement.

Write a C program to print Hello World by using a function without a return value

#include
void displayMessage() {
    printf("Hello! I am a void function.\n");
    printf("I perform an action directly.");
}
int main() {
    displayMessage();
    return 0;
}
// Hello! I am a void function.
// I perform an action directly.

Parameters and Arguments

1. Parameters: These are the variables listed inside the parentheses in the function definition. They act as empty boxes waiting for data. They define what kindof data the function needs.

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

‘a’ and ‘b’ are PARAMETERS and they are just labels waiting for values.

2. Arguments: These are the real values you pass to the function when you call it.They are the actual data that fills the empty boxes.

int main() {
    int result = multiply(4, 5); 
    return 0;
}

4 and 5 are ARGUMENTS. They are the real data being sent. When the code runs the arguments are sent to the parameter.

Consider a Code example below

				
					#include <stdio.h>
void printSum(int x, int y) {
    int sum = x + y;
    printf("Sum: %d\n", sum);
}
int main() {
    int a = 10;
    int b = 20;
    printSum(a, b); 
        printSum(50, 50);

    return 0;
}

// Sum: 30
// Sum: 100

In this code, x and y are the parameters (placeholders waiting for data), while the variables a, b and the numbers 50 are the arguments (actual values) passed to fill those placeholders.

Types of Function Calls

1.Call by Value:

In this method the value of the variable is copied into the function parameter. Here modifying the parameter inside the function does not affect the original variable.

				
					#include <stdio.h>
void tryToChange(int x) {
    x = 100;     // This only changes the copy inside this function
    printf("Inside Function: %d\n", x);
}
int main() {
    int a = 10;
    tryToChange(a); // Pass the value (copy)
    
    // The original 'a' remains 10
    printf("Inside Main: %d", a); 
    return 0;
}

// Inside Function: 100
// Inside Main: 10

This code demonstrates Call by Value, where the function receives a copy of a (assigned to x), so changing x to 100 inside the function leaves the original variable a unchanged at 10.

2. Call by Reference

In this method, the address of the variable is passed to the function using pointers. The function goes to that specific memory address and modifies the original variable. This technique is widely used in array manipulation, Dynamic memory handling, Data structures

				
					#include <stdio.h>

// Note the '*' (Pointer) expects an address
void actualChange(int *ptr) {
    *ptr = 100; // Go to the address and change the value there
    printf("Inside Function: %d\n", *ptr);
}

int main() {
    int a = 10;
    
    actualChange(&a); // Pass the address of 'a'
    
    // The original 'a' is now changed
    printf("Inside Main: %d", a); 

    return 0;
}

// Inside Function: 100
// Inside Main: 100

This code demonstrates Call by Reference, where passing the memory address of a (&a) allows the function to access and modify the original variable directly via the pointer, permanently changing a from 10 to 100.

Recursive Functions in C

A recursive function is a function that calls itself to solve a problem by breaking it down into smaller, simpler versions of the same problem. Every recursive function must have a Base Case (condition to stop) and a Recursive Case (the self-call).

Write a C program to calculate the Factorial of a number by using a recursive function.

The code below calculates 5! by repeatedly calling factorial with a smaller number (5 * 4 * 3 * 2 * 1) until it hits the base case of 0.

				
					#include <stdio.h>
int factorial(int n) {
    if (n == 0)
        return 1;
    else        // Recursive Case: n * factorial of (n-1)
        return n * factorial(n - 1); 
}
int main() {
    int result = factorial(5);
    printf("Factorial of 5 is: %d", result); // Output: 120
    return 0;
}
// Factorial of 5 is: 120

Write a C Program for the Fibonacci Sequence using recursive functions

The code uses a for loop to repeatedly trigger the recursive Fibonacci function, printing the result for index 0, then index 1, then index 2, and so on, until the sequence is complete.

				
					#include <stdio.h>

// Standard Recursive Function
int fibonacci(int n) {
    if (n == 0) return 0;
    if (n == 1) return 1;
    return fibonacci(n - 1) + fibonacci(n - 2);
}

int main() {
    int limit = 10; // Number of terms to print

    printf("Fibonacci Sequence: ");
    
    // Loop through 0 to limit and print each result
    for (int i = 0; i < limit; i++) {
        printf("%d ", fibonacci(i));
    }

    return 0;
}

// Fibonacci Sequence: 0 1 1 2 3 5 8 13 21 34

Loop i	Function Call	Recursive Path / Calculation	Result
0	fibonacci( 0 )	Base case: if (n == 0)	0
1	fibonacci( 1 )	Base case: if (n == 1)	1
2	fibonacci( 2 )	fibonacci(1) + fibonacci(0) -> 1 + 0	1
3	fibonacci( 3 )	fibonacci(2) + fibonacci(1) -> 1 + 1	2
4	fibonacci( 4 )	fibonacci(3) + fibonacci(2) -> 2 + 1	3
5	fibonacci( 5 )	fibonacci(4) + fibonacci(3) -> 3 + 2	5

Functions using Pointers

Unlike a regular variable that stores data, a function pointer stores the address of executable code. Instead of pointing to data (like an int or char), it points to executable code.

This allows you to pass functions as arguments to other functions (Callbacks) or select which function to run at runtime.

Syntax

The syntax is specific because you must tell the compiler what the function looks like (return type and parameters).

ReturnType (*PointerName)(ParameterTypes);

Consider the example code

				
					#include <stdio.h>
int add(int a, int b) {
    return a + b;
}
int main() {
    // A pointer named 'func_ptr' that can point to any function 
    int (*func_ptr)(int, int);
    func_ptr = &add; 
    int result = (*func_ptr)(10, 20); // Equivalent to add(10, 20)

    printf("Result: %d", result);
    return 0;
}

// Result: 30

This code demonstrates how to store the memory address of the add function into a pointer variable named func_ptr and then execute the function indirectly by calling that pointer.

Why are they useful? (Callbacks)

Function pointers allow you to pass logic as data. A common use is Callbacks, where one function calls another function that you provide.

				
					#include <stdio.h>
void sayHello() {
    printf("Hello!");
}
// This function accepts ANOTHER function as a parameter
void executeFunction(void (*action)()) {
    printf("Preparing to run...\n");
    action(); // Calls 'sayHello'
}
int main() {
    executeFunction(sayHello);
    return 0;
}

// Preparing to run...
// Hello!

Applications of Functions in C

1) Modular Programming

Functions help divide a large and complex program into small, independent modules. Each module performs a specific task, making the program easier to design, understand, and manage.

2) Code Reusability

A function written once can be used multiple times in the same program or in different programs. This reduces code duplication and saves development time.

3) Easy Debugging and Maintenance

When a program is divided into functions, errors can be identified and fixed easily by checking individual functions. Updating or modifying a function does not affect the entire program.

4) Team-Based and Large-Scale Development

In large projects, different programmers can work on different functions simultaneously. This improves productivity and makes collaboration efficient.

5) System-Level and Embedded Applications

Functions are widely used in operating systems, device drivers, embedded systems, and real-time applications to perform hardware control, memory management, and task scheduling efficiently.

Frequently Asked Questions (FAQs)

1) Why is a pointer used in a function?

A pointer is used in a function to modify the original variable, pass large data efficiently, and share memory locations between functions. It enables call-by-reference behavior in C.

2) Why are custom (user-defined) functions used in C?

Custom functions are used to:

Reduce code repetition
Improve readability
Divide a program into logical parts
Make debugging and maintenance easier

They allow programmers to solve specific problems efficiently.

3) What is an override function?

Function overriding does not exist in C.
C does not support object-oriented features like inheritance, so function overriding is not applicable.
It is a concept found in C++ and Java, not in C.

4) What are the types of functions in C language?

There are two types of functions in C:

Built-in (library) functions
User-defined functions

5) What are built-in functions?

Built-in functions are predefined functions provided by C libraries to perform common tasks like input, output, math operations and string handling.