Jan 22, 2026
## Chapter 6: Functions
**What does a function mean?**
You can think of a function as a small program or a working machine. Instead of writing the entire code every time you need to perform a task repeatedly, you put it into a function once and call it whenever needed.
**Real-life example**
Like the "calculator" on your mobile phone.
You don't create a new calculator every time; you just open it and use it – that's what a function is.
Why use functions?
Reusability:
* Write the function once
* Needed in 10 places -> call it 10 times
* Code remains short and clean
Organization:
* Writing the entire program at once can be overwhelming
* With functions:
* Each task is separate
* Easier to understand
Just like a whole house isn't built in one room, it's built room by room.
Maintenance:
* If an error occurs
* You don't have to look at the entire program
* Just fix that specific function
Readability:
* It's easy to understand by looking at the name
For example: add(), login(), calculateMarks()
Function Syntax
Now let's make the syntax less intimidating and easier to understand
```c
return_type function_name(parameters) {
// The code goes here
return value;
}
```
Now let's understand each part
**return_type**
* What the function will return
* For example:
* int -> will return a number
* float -> will return a decimal
* void -> will not return anything
**function_name**
* The name of the function
* The name should be such that the function's purpose is clear
Incorrect: f1()
Correct: addNumbers()
**function body { }**
* The actual work happens here
* Calculations, logic, printing, etc.
**return value**
* The final result of the function
* If int is specified, it is necessary to return an integer
Simple Function Example
```c
#include
// Function Declaration (Prototype)
void greet();
// What does this mean?
// - We are telling the compiler beforehand: "A function named greet is coming"
// - void means: This function will not return anything
int main() {
greet(); // Function call
greet(); // Can be called multiple times
return 0;
}
// What is happening here?
// - The program also starts from here
// - greet(); -> The function was called
// - Called twice -> therefore the output will also appear twice
// Meaning: The function was written once but used multiple times. This is the biggest advantage of functions.
// return 0;
// - The program ended successfully
// - 0 = no error
// Function Definition
void greet() {
printf("Hello! Welcome to C programming.n");
}
// What's happening here?
// - The actual work is now defined
// - Whenever greet() is called: This message will be printed on the screen
// Note: void -> returns nothing. Only the message will be printed on the screen.
```
**Functions with Parameters**
```c
#include
void greetPerson(char name[]) {
printf("Hello, %s! Nice to meet you.n", name);
}
```
**Understand this in simple language:**
* This function takes a name
* %s means -> string (name)
* name -> the name that will be passed
Meaning: Whatever name you give, that will appear in the message.
Functions that Return Values
In the C language, when a function returns a result, it is called a Return Value Function.
The biggest advantage of such functions is that:
* We can store the result in a variable
* Or we can use the function directly as an expression
What does a return value function do?
* The function takes input
* Performs processing
* Returns a value using the return keyword
This value is used in main() or the function that called it.
```c
#include
// Function that adds two numbers and returns the result
int calculateSum(int num1, int num2) {
int total;
total = num1 + num2;
return total; // The result is being returned
}
int main() {
int answer; // The function's result is stored in a variable
answer = calculateSum(7, 4);
printf("7 + 4 = %dn", answer);
// The function can also be used directly in printf
printf("15 + 25 = %dn", calculateSum(15, 25));
return 0;
}
```
**Practical Example:**
When we learn the C language, simply understanding the theory is not enough. Small practical programs help us understand functions, switch case, and user input better. Therefore, here we will see an example of a simple calculator.
Calculator Program (Functions + Switch Case)
In this program:
* There is a separate function for each operation
* Input is taken from the user
* The operation is selected using a switch case
```c
#include
// Function for addition
int sumNumbers(int x, int y) {
return x + y;
}
// Function for subtraction
int minusNumbers(int x, int y) {
return x - y;
}
// Function for multiplication
int multiplyNumbers(int x, int y) {
return x * y;
}
// Function for division
float divideNumbers(int x, int y) {
if (y != 0) {
return (float)x / y; // typecasting to get a decimal result
} else {
printf("Error: Division by zero is not allowedn");
return 0.0;
}
}
int main() {
int firstNum, secondNum;
int option;
// Getting numbers from the user
printf("Enter the first number: ");
scanf("%d", &firstNum);
printf("Enter the second number: ");
scanf("%d", &secondNum);
// Displaying the menu
printf("nWhich operation do you want to perform:n");
printf("1. Additionn");
printf("2. Subtractionn");
printf("3. Multiplicationn");
printf("4. Divisionn");
printf("Enter your choice: ");
scanf("%d", &option);
switch(option) {
case 1:
printf("Result: %dn", sumNumbers(firstNum, secondNum));
break;
case 2:
printf("Result: %dn", minusNumbers(firstNum, secondNum));
break;
case 3:
printf("Result: %dn", multiplyNumbers(firstNum, secondNum));
break;
case 4:
printf("Result: %.2fn", divideNumbers(firstNum, secondNum));
break;
}
return 0;
}
```
---
