UNIT 3 Functions and Arrays
1. Concept of Function
A function is a block of code designed to perform a specific task. It
allows us to break down a program into smaller, manageable
sections, making the program more organized and
modular. Functions help reduce code repetition, enhance reusability,
and improve readability.
A function generally has:
∙ Return Type: The type of value it returns (e.g., int, void).
∙ Function Name: A unique identifier for the function.
∙ Parameters: Input values passed into the function (optional).
∙ Function Body: The block of code that performs the specific
task.
Example:
#include <stdio.h>
// Function definition
int add(int a, int b) {
return a + b; // Function returns the sum of a and b
}
int main() {
int result = add(3, 4); // Function call
printf("The sum is: %d\n", result);
return 0;
}
2. Advantages of Modular Design
Modular design in programming refers to breaking a program
into smaller, self-contained functions (modules). Key benefits
include:
∙ Reusability: Functions can be reused across different parts of the
program or in other programs.
∙ Maintainability: Smaller, well-defined modules are easier
to maintain and debug. ∙ Clarity: Breaking code into
functions makes the program easier to understand. ∙
Separation of Concerns: Different aspects of a program can
be handled by separate functions, reducing complexity.
3. Standard Library Functions
C provides a rich set of standard library functions that perform
common tasks, such as input/output, mathematical operations, and
string manipulation. These functions are defined in various libraries
like stdio.h, math.h, and string.h.
∙printf(): Prints output to the console.
∙scanf(): Reads input from the user.
∙strlen(): Returns the length of a string.
∙sqrt(): Returns the square root of a number.
Example of using standard functions:
#include <stdio.h>
#include <math.h>
int main() {
double num = 16.0;
printf("Square root of %.2f is %.2f\n", num, sqrt(num)); //
Using standard math function return 0;
}
User-Defined Functions
1. Function Declaration
A function declaration or prototype informs the compiler about the function's
name, return type, and parameters before its definition.
Syntax:
return_type function_name(parameter1_type, parameter2_type, ...);
Example:
int add(int, int); // Function prototype
2. Function Definition
This provides the actual implementation of the function.
Syntax:
return_type function_name(parameter1, parameter2, ...) {
// Function body
}
Example:
int add(int a, int b) {
return a + b;
}
3. Function Call
A function is called by using its name and passing arguments (if required).
Example:
int result = add(5, 10); // Function call
4. Parameter Passing (By Value)
When arguments are passed to a function by value, the function gets copies of the
actual values, and changes made to the parameters do not affect the original
variables.
Example:
void increment(int a) {
a = a + 1;
}
5. Return Statement
The return statement is used to return a value from a function to the
calling function.
Example:
int square(int x) {
return x * x; // Returning the square of x
}
6. Recursive Functions
A recursive function is a function that calls itself to solve a smaller instance
of the same problem.
Example of factorial:
int factorial(int n) {
if (n == 0) return 1;
else return n * factorial(n - 1); // Recursive call
}
7. Scope of Variables
∙Local Variables: Defined within a function, accessible
only within that function. ∙
Global Variables: Defined outside all functions,
accessible to all functions in the program.
∙ Static Variables: Retain their values between function
calls, but have a local scope.
8. Storage Classes
∙ auto: Default storage class for local variables (automatically
allocated and deallocated). ∙
static: Retains variable value across function calls. Local to the
function. ∙
extern: Allows a variable to be shared across multiple files.
∙ register: Suggests that a variable be stored in a CPU register for
faster access (though not guaranteed).
Arrays in C
1. Concept of Array
An array is a collection of elements of the same type stored in contiguous memory
locations. It allows us to store multiple values in a single variable, and elements are
accessed by an index (starting from 0).
2. Types of Arrays
∙One-Dimensional Array: A linear array that stores data in a
single row.
Example:
int numbers[5] = {1, 2, 3, 4, 5};
Two-Dimensional Array: A 2D array can be thought of as a matrix or a table with
rows and columns.
Example:
int matrix[3][3] = {
{1, 2, 3},
{4, 5, 6},
{7, 8, 9}
};
Multidimensional Arrays: Arrays with more than two dimensions. These are rarely
used but useful for certain applications like matrices in scientific computing.
Example:
int cube[3][3][3]; // A 3D array
3. Array Operations
Declaration: Arrays are declared by specifying the type and size.
Example:
int arr[10]; // Declare an array of 10 integers
Initialization: Arrays can be initialized during declaration.
Example:
int arr[3] = {10, 20, 30}; // Initialization
∙ Accessing Elements: Use the index to access or modify array elements.
Example:
int a = arr[0]; // Access the first element
arr[1] = 100; // Modify the second element
4. Memory Representation of Two-Dimensional Arrays
Arrays in C are stored in contiguous memory locations. For a 2D array:
Row-major order: The rows are stored one after the other in memory. ∙
Column-major order: The columns are stored one after the other in
memory.
For a 2D array matrix[3][3]:
Row-major order: Memory layout will be: matrix[0][0], matrix[0][1],
matrix[0][2], matrix[1][0], matrix[1][1], matrix[1][2], matrix[2][0], matrix[2][1],
matrix[2][2].
Column-major order: Memory layout will be: matrix[0][0], matrix[1][0],
matrix[2][0], matrix[0][1], matrix[1][1], matrix[2][1], matrix[0][2], matrix[1][2],
matrix[2][2].
5. Passing Arrays to Functions
When passing an array to a function, the array is passed as a pointer to its
first element.
void printArray(int arr[], int size) {
for (int i = 0; i < size; i++) {
printf("%d ", arr[i]);
}
}
6. Merging Two Sorted Arrays
To merge two sorted arrays, we compare elements from both arrays and insert them
into a new array in sorted order.
void merge(int arr1[], int arr2[], int result[], int n1, int n2) {
int i = 0, j = 0, k = 0;
while (i < n1 && j < n2) {
if (arr1[i] < arr2[j]) {
result[k++] = arr1[i++];
} else {
result[k++] = arr2[j++];
}
}
while (i < n1) result[k++] = arr1[i++];
while (j < n2) result[k++] = arr2[j++];
}
7. Matrix Operations
Matrices can be represented as 2D arrays, and common matrix operations
include addition, subtraction, and multiplication.
Matrix Addition: Adding corresponding elements of two matrices.
Matrix Multiplication: Multiplying rows of one matrix with columns of another
matrix.
void addMatrices(int A[3][3], int B[3][3], int result[3][3])
{
for (int i = 0; i < 3; i++) {
for (int j = 0; j < 3; j++) {
result[i][j] = A[i][j] + B[i][j];
}
}
}
