Scribd
Upload
21 views

C Unit 3 notes

Uploaded by

shrushti0221
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as PDF, TXT or read online on Scribd
21 views

C Unit 3 notes

Uploaded by

shrushti0221
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as PDF, TXT or read online on Scribd
You are on page 1/ 6

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];
}
}
}

You might also like