Unit 5: Arrays, User-Defined Functions, and Pointers

1. Arrays

An array is a fixed-size, sequential collection of elements of the same data type. Elements are stored in contiguous memory locations and are accessed using an index.

One-dimensional Arrays

• Declaration of One-dimensional Arrays: You must specify the type and size.

  int marks[30]; // Declares an array named 'marks' that can hold 30 integers float prices[10]; // Declares an array to hold 10 floats

• Initialization of One-dimensional Arrays: You can assign values at declaration.

  // Size is explicitly given int numbers[5] = {10, 20, 30, 40, 50}; // Size is inferred from the list int numbers[] = {10, 20, 30}; // Compiler creates an array of size 3

• Accessing Elements: Use the index in square brackets []. C is 0-indexed.

  int val = numbers[0]; // Accesses the first element (10) numbers[2] = 35; // Changes the third element to 35

2. User-defined Functions

A function is a self-contained block of code that performs a specific task. You have used built-in functions like printf; C also lets you create your own.

Need for Functions

• Modularity: Breaks a large, complex program into smaller, manageable pieces.
• Reusability: You can write a function once (e.g., calculateAverage()) and call it many times from different places.
• Readability & Debugging: Makes code easier to read and understand. It's easier to fix a bug inside one small function than in one giant main().

Elements of User-defined Functions

A function has three parts:

1. Function Declaration (Prototype): Tells the compiler the function's name, return type, and parameters. It's placed at the top of the file.

   int add(int a, int b); // This is a function prototype

2. Function Definition: This is the actual code for the function.

    int add(int a, int b) { // Function header // Function body int sum = a + b; return sum; }

3. Function Call: This is how you execute the function from main() or another function.

    int main() { int result = add(5, 10); // This is a function call return 0; }

Return Values and their Types

A function can send a single value back to the code that called it using the return keyword.

• The return type (e.g., int, float) must match the value being returned.
• A function with a void return type does not return any value.

Category of Functions

Functions can be categorized based on whether they take arguments (input) or return a value (output).

1. No Arguments and No Return Values: Good for printing menus or fixed messages.

   void printHello() { printf("Hello!"); }

2. Arguments but No Return Values: Takes data in but doesn't send a result back.

   void printNumber(int n) { printf("The number is %d", n); }

3. Arguments with Return Values: The most common type. Takes data, processes it, and returns the result.

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

4. No Arguments but Returns a Value: Good for getting input from the user.

   int getAge() { int age; printf("Enter age: "); scanf("%d", &age); return age; }

Passing Arrays to Functions

When you pass an array to a function, C does not create a copy. Instead, it passes a pointer (the address) to the first element.

This means the function can modify the original array in main().

 // 'arr' is actually a pointer (int*) void doubleArray(int arr[], int size) { for (int i = 0; i < size; i++) { arr[i] = arr[i] * 2; // Modifies the original array } } int main() { int myNums[] = {1, 2, 3}; doubleArray(myNums, 3); // myNums is now {2, 4, 6} return 0; } 

Recursion

Recursion is a process where a function calls itself, either directly or indirectly. It's a powerful alternative to loops for solving problems that can be broken into smaller, similar sub-problems.

A recursive function must have:

1. Base Case: A condition that stops the recursion.
2. Recursive Step: The part that calls the function again, but with a smaller problem.

 // Example: Factorial long factorial(int n) { if (n == 0) { return 1; // Base Case } else { return n * factorial(n - 1); // Recursive Step } } 

3. Pointers

Introduction to pointers in C (Basic Concepts)

A pointer is a special variable that stores the memory address of another variable.

There are two key pointer operators:

• & (Address-of operator): Gets the memory address of a variable.
• * (Dereference/Indirection operator): Gets the value *at* a given memory address.

 int x = 10; // A normal variable int *p; // 'p' is a pointer to an integer p = &x; // Assign the ADDRESS of 'x' to 'p' // Now 'p' "points to" 'x' printf("Value of x: %d\n", x); // Prints 10 printf("Address of x: %p\n", &x); // Prints the address (e.g., 0x7ffc1234) printf("Value of p: %p\n", p); // Prints the same address (0x7ffc1234) printf("Value at p: %d\n", *p); // Prints 10 (goes to address, gets value) *p = 20; // Go to the address 'p' holds and change the value printf("New value of x: %d\n", x); // Prints 20