Control Structures in C and Switch-Based Arithmetic Calculator

Part 1: Control Structures in C

Control structures determine the flow of execution of a program. C provides three main categories:

1. Sequential Structure

Statements are executed one after another in the order they appear. This is the default flow.

Statement 1 → Statement 2 → Statement 3

2. Selection (Decision) Structures

Used to choose between alternative paths based on a condition.

a) if Statement

if (condition) {
    // executes if condition is true
}

b) if-else Statement

if (condition) {
    // executes if true
} else {
    // executes if false
}

c) if-else if-else (Ladder)

if (condition1) { ... }
else if (condition2) { ... }
else { ... }

d) switch Statement

Used when a variable is compared against multiple constant values.

switch (expression) {
    case value1: // statements; break;
    case value2: // statements; break;
    default:     // statements;
}

3. Iteration (Loop) Structures

Used to repeat a block of statements.

a) for Loop

for (initialization; condition; update) {
    // body
}

b) while Loop

while (condition) {
    // body
}

c) do-while Loop

do {
    // body
} while (condition);

Executes the body at least once before checking the condition.

4. Jump Structures

Used to transfer control unconditionally.

Part 2: C Program Using Switch for Arithmetic Operations

#include <stdio.h>

int main() {
    int a, b, choice;
    float result;

    // Input two integers
    printf("Enter first integer: ");
    scanf("%d", &a);

    printf("Enter second integer: ");
    scanf("%d", &b);

    // Display menu
    printf("\n--- Arithmetic Operations Menu ---\n");
    printf("1. Addition\n");
    printf("2. Subtraction\n");
    printf("3. Multiplication\n");
    printf("4. Division\n");
    printf("5. Modulus\n");
    printf("Enter your choice (1-5): ");
    scanf("%d", &choice);

    // Switch statement for operation selection
    switch (choice) {
        case 1:
            result = a + b;
            printf("Result: %d + %d = %.2f\n", a, b, result);
            break;

        case 2:
            result = a - b;
            printf("Result: %d - %d = %.2f\n", a, b, result);
            break;

        case 3:
            result = a * b;
            printf("Result: %d * %d = %.2f\n", a, b, result);
            break;

        case 4:
            if (b == 0) {
                printf("Error: Division by zero is not allowed.\n");
            } else {
                result = (float)a / b;
                printf("Result: %d / %d = %.2f\n", a, b, result);
            }
            break;

        case 5:
            if (b == 0) {
                printf("Error: Modulus by zero is not allowed.\n");
            } else {
                printf("Result: %d %% %d = %d\n", a, b, a % b);
            }
            break;

        default:
            printf("Invalid choice! Please enter a number between 1 and 5.\n");
    }

    return 0;
}

Sample Output

Enter first integer: 10
Enter second integer: 3

--- Arithmetic Operations Menu ---
1. Addition
2. Subtraction
3. Multiplication
4. Division
5. Modulus
Enter your choice (1-5): 4

Result: 10 / 3 = 3.33

Key Points About the Switch Statement Used

Recursion and Factorial Program

What is Recursion?

Recursion is a programming technique where a function calls itself directly or indirectly to solve a problem. A recursive function solves a problem by breaking it down into smaller subproblems of the same type until it reaches a base case (a condition where the function stops calling itself).

Every recursive function must have:

1. Base Case - the condition that terminates the recursion
2. Recursive Case - the part where the function calls itself

Factorial Using Recursion

Mathematical Definition

$$n! = \begin{cases} 1 & \text{if } n = 0 \text{ or } n = 1 \ n \times (n-1)! & \text{if } n > 1 \end{cases}$$

Example: 5! = 5 × 4 × 3 × 2 × 1 = 120

C Program

#include <stdio.h>

// Recursive function to calculate factorial
int factorial(int n) {
    // Base case
    if (n == 0 || n == 1) {
        return 1;
    }
    // Recursive case
    else {
        return n * factorial(n - 1);
    }
}

int main() {
    int num;
    printf("Enter a positive integer: ");
    scanf("%d", &num);

    if (num < 0) {
        printf("Factorial is not defined for negative numbers.\n");
    } else {
        printf("Factorial of %d = %d\n", num, factorial(num));
    }
    return 0;
}

Trace of Execution (for n = 5)

factorial(5)
  = 5 * factorial(4)
        = 4 * factorial(3)
              = 3 * factorial(2)
                    = 2 * factorial(1)
                              = 1       <-- Base case
                    = 2 * 1 = 2
              = 3 * 2 = 6
        = 4 * 6 = 24
  = 5 * 24 = 120

Output:

Enter a positive integer: 5
Factorial of 5 = 120

Key Points

Pointer and Its Similarity with Array

What is a Pointer?

A pointer is a variable that stores the memory address of another variable rather than storing a direct value. It "points to" the location in memory where data is stored.

Syntax:

data_type *pointer_name;

Example:

int a = 10;
int *p;
p = &a;   // p holds the address of variable a

Here, &a gives the address of a, and *p (dereferencing) gives the value stored at that address, i.e., 10.

Similarity Between Array and Pointer

In C, arrays and pointers are closely related. The key similarities are:

1. Array Name as a Pointer

The name of an array acts as a constant pointer to the first element of the array.

int arr[5] = {10, 20, 30, 40, 50};
int *p = arr;   // p points to arr[0]

Here, arr and &arr[0] are equivalent.

2. Accessing Elements

Array elements can be accessed using pointer notation, and pointer elements can be accessed using array notation.

printf("%d", arr[2]);    // Output: 30
printf("%d", *(p+2));    // Output: 30  (same result)

3. Pointer Arithmetic

Both arrays and pointers support arithmetic operations like increment and decrement to traverse elements.

p++;   // moves to the next element (next memory address)

4. Address Relationship

For an array arr:

• arr = &arr[0] (address of first element)
• arr + 1 = &arr[1] (address of second element)
• arr + i = &arr[i] (address of i-th element)

Key Difference (Note)

Although similar, an array name is a constant pointer -- its address cannot be changed, whereas a pointer variable can be reassigned to point to different locations.

p = p + 1;   // Valid
arr = arr + 1; // ERROR: array name is a constant pointer

In summary, arrays and pointers are interchangeable in many contexts in C, making pointer knowledge essential for efficient array manipulation.

Short Notes

a) Macro

A macro is a preprocessor directive in C that allows a name (identifier) to be associated with a piece of code, a constant, or an expression. The C preprocessor replaces every occurrence of the macro name with its defined text before actual compilation begins.

Types of Macros

1. Object-like Macro (Simple/Symbolic Constant)

#define PI 3.14159
#define MAX 100

Every occurrence of PI in the code is replaced by 3.14159.

2. Function-like Macro (Macro with Arguments)

#define SQUARE(x)  ((x)*(x))
#define MAX(a,b)   ((a)>(b) ? (a) : (b))

Usage: SQUARE(5) is replaced by ((5)*(5)) = 25.

Key Points

• Defined using #define directive.
• Processed by the preprocessor, not the compiler.
• No type checking is performed (unlike functions).
• Parentheses should be used carefully to avoid operator precedence errors.
• Macros can be undefined using #undef.
• They make code more readable, portable, and easy to maintain.

b) Opening and Closing a File

In C, file handling is done using the standard library <stdio.h>. Before reading from or writing to a file, it must be opened, and after operations are complete, it must be closed.

Opening a File

The fopen() function is used to open a file.

Syntax:

FILE *fptr;
fptr = fopen("filename", "mode");

• FILE * is a pointer to a file structure.
• If the file cannot be opened, fopen() returns NULL.

File Opening Modes

Closing a File

The fclose() function is used to close an opened file.

Syntax:

fclose(fptr);

• It flushes any unwritten data to the file.
• Releases the file pointer resource.
• Returns 0 on success, EOF on failure.

Example

#include <stdio.h>
int main() {
    FILE *fptr;
    fptr = fopen("data.txt", "w");   // Open file for writing
    if (fptr == NULL) {
        printf("Error opening file!\n");
        return 1;
    }
    fprintf(fptr, "Hello, File!\n"); // Write to file
    fclose(fptr);                    // Close the file
    return 0;
}

Note: Always check if fopen() returns NULL before performing file operations, and always close the file after use to prevent data loss or resource leaks.