Functions in C
Function declaration, definition, parameters, return values, and recursion.
Function Basics
A function is a block of code that performs a specific task. Functions help organize code, make it reusable, and easier to maintain.
function_syntax.c
#include <stdio.h>
// Function declaration (prototype)
return_type function_name(parameter_list);
// Function definition
return_type function_name(parameter_list) {
// function body
return value;
}
// Example
int add(int a, int b) { // Function header
int sum = a + b; // Function body
return sum; // Return statement
}
function_example.c
#include <stdio.h>
// Function declaration (prototype)
int add(int a, int b);
int subtract(int a, int b);
void printMessage(void);
int main() {
int x = 10, y = 5;
// Function calls
int sum = add(x, y);
int diff = subtract(x, y);
printf("Sum: %d\n", sum);
printf("Difference: %d\n", diff);
printMessage();
return 0;
}
// Function definitions
int add(int a, int b) {
return a + b;
}
int subtract(int a, int b) {
return a - b;
}
void printMessage(void) {
printf("Hello from function!\n");
}
Types of Functions
1. No Arguments, No Return Value
void greet(void) {
printf("Hello!\n");
}
// Call: greet();
2. With Arguments, No Return Value
void greetPerson(char name[]) {
printf("Hello, %s!\n", name);
}
// Call: greetPerson("Alice");
3. No Arguments, With Return Value
int getNumber(void) {
return 42;
}
// Call: int num = getNumber();
4. With Arguments and Return Value
int multiply(int a, int b) {
return a * b;
}
// Call: int result = multiply(5, 3);
Math Functions Library
math_functions.c
#include <stdio.h>
#include <math.h>
int main() {
double num = 16.0;
// Square root
printf("sqrt(%.0f) = %.2f\n", num, sqrt(num));
// Power
printf("pow(2, 3) = %.2f\n", pow(2, 3));
// Absolute value
printf("abs(-10) = %d\n", abs(-10));
printf("fabs(-10.5) = %.2f\n", fabs(-10.5));
// Rounding
printf("ceil(3.2) = %.2f\n", ceil(3.2));
printf("floor(3.8) = %.2f\n", floor(3.8));
printf("round(3.5) = %.2f\n", round(3.5));
// Trigonometric
double angle = 45.0 * M_PI / 180.0; // Convert to radians
printf("sin(45°) = %.4f\n", sin(angle));
printf("cos(45°) = %.4f\n", cos(angle));
// Logarithm
printf("log(10) = %.4f\n", log(10));
printf("log10(100) = %.2f\n", log10(100));
return 0;
}
Recursion
Recursion is when a function calls itself to solve a problem by breaking it into smaller subproblems.
recursion.c
#include <stdio.h>
// Factorial: n! = n * (n-1)!
// Base case: 0! = 1, 1! = 1
int factorial(int n) {
if (n <= 1)
return 1; // Base case
return n * factorial(n - 1); // Recursive case
}
// Fibonacci: F(n) = F(n-1) + F(n-2)
// Base case: F(0) = 0, F(1) = 1
int fibonacci(int n) {
if (n <= 0)
return 0;
if (n == 1)
return 1;
return fibonacci(n - 1) + fibonacci(n - 2);
}
// Sum of digits
int sumOfDigits(int n) {
if (n == 0)
return 0;
return (n % 10) + sumOfDigits(n / 10);
}
// Power: x^n
int power(int base, int exp) {
if (exp == 0)
return 1;
return base * power(base, exp - 1);
}
int main() {
printf("Factorial of 5: %d\n", factorial(5));
printf("Fibonacci sequence: ");
for (int i = 0; i < 10; i++)
printf("%d ", fibonacci(i));
printf("\n");
printf("Sum of digits of 12345: %d\n", sumOfDigits(12345));
printf("2^8 = %d\n", power(2, 8));
return 0;
}
Variable Scope
| Type | Scope | Lifetime | Storage |
|---|---|---|---|
| Local | Function only | Function execution | Stack |
| Global | Entire program | Program lifetime | Data segment |
| static | Function/block | Program lifetime | Data segment |
| extern | Multiple files | Program lifetime | Data segment |
scope.c
#include <stdio.h>
// Global variable
int globalVar = 10;
void demoLocal() {
int localVar = 20; // Local variable
printf("Local: %d\n", localVar);
printf("Global: %d\n", globalVar);
}
void demoStatic() {
static int count = 0; // Retains value between calls
count++;
printf("Static count: %d\n", count);
}
int main() {
printf("Global in main: %d\n", globalVar);
demoLocal();
// Static demonstration
demoStatic(); // Prints 1
demoStatic(); // Prints 2
demoStatic(); // Prints 3
return 0;
}
Complete Calculator Program
calculator.c
#include <stdio.h>
// Function prototypes
void showMenu(void);
int add(int a, int b);
int subtract(int a, int b);
int multiply(int a, int b);
float divide(int a, int b);
int main() {
int choice, num1, num2;
do {
showMenu();
printf("Enter choice: ");
scanf("%d", &choice);
if (choice >= 1 && choice <= 4) {
printf("Enter two numbers: ");
scanf("%d %d", &num1, &num2);
}
switch(choice) {
case 1:
printf("Result: %d\n", add(num1, num2));
break;
case 2:
printf("Result: %d\n", subtract(num1, num2));
break;
case 3:
printf("Result: %d\n", multiply(num1, num2));
break;
case 4:
if (num2 != 0)
printf("Result: %.2f\n", divide(num1, num2));
else
printf("Error: Division by zero!\n");
break;
case 5:
printf("Goodbye!\n");
break;
default:
printf("Invalid choice!\n");
}
printf("\n");
} while (choice != 5);
return 0;
}
void showMenu(void) {
printf("===== CALCULATOR =====\n");
printf("1. Add\n");
printf("2. Subtract\n");
printf("3. Multiply\n");
printf("4. Divide\n");
printf("5. Exit\n");
}
int add(int a, int b) { return a + b; }
int subtract(int a, int b) { return a - b; }
int multiply(int a, int b) { return a * b; }
float divide(int a, int b) { return (float)a / b; }