Looping Statements in C

Definition of Looping Statement [2 marks]

A looping statement (also called an iterative statement) is a control structure that allows a block of statements to be executed repeatedly as long as a given condition remains true. Looping avoids writing the same code multiple times and is used when a task needs to be performed a fixed or variable number of times.

As per the notes, iterative statements in C include:

• for
• while
• do...while

Types of Looping Statements [8 marks]

1. while Loop

Syntax:

while (condition)
{
    // body of loop
}

How it works:

• The condition is checked before executing the body.
• If the condition is true, the body executes.
• If the condition is false at the start, the body is never executed.
• It is called an entry-controlled loop.

Example: Print numbers 1 to 5

#include<stdio.h>
void main()
{
    int i = 1;
    while (i <= 5)
    {
        printf("%d\n", i);
        i++;
    }
}

Output:

1
2
3
4
5

2. do...while Loop

Syntax:

do
{
    // body of loop
} while (condition);

How it works:

• The body is executed first, then the condition is checked.
• The body executes at least once even if the condition is false.
• It is called an exit-controlled loop.

Example: Print numbers 1 to 5

#include<stdio.h>
void main()
{
    int i = 1;
    do
    {
        printf("%d\n", i);
        i++;
    } while (i <= 5);
}

Output:

1
2
3
4
5

Key difference from while: Even if i starts at 6, the body runs once before checking the condition.

3. for Loop

Syntax:

for (initialization; condition; increment/decrement)
{
    // body of loop
}

How it works:

• Initialization: Executed once at the beginning (e.g., i = 1).
• Condition: Checked before each iteration; if false, loop ends.
• Increment/Decrement: Executed after each iteration.
• It is also an entry-controlled loop and is preferred when the number of iterations is known in advance.

Example: Find the sum of first 10 natural numbers

#include<stdio.h>
void main()
{
    int i, sum = 0;
    for (i = 1; i <= 10; i++)
    {
        sum = sum + i;
    }
    printf("Sum = %d", sum);
}

Output:

Sum = 55

Comparison Table

Summary

Looping statements are essential in C programming to perform repetitive tasks efficiently. The for loop is used when the number of iterations is known; the while loop is used when the condition is checked before execution; and the do...while loop guarantees at least one execution of the loop body.

Array: Definition, Benefits, and Matrix Addition Program

1. Definition of Array [1 mark]

An array is a collection of similar (same data type) elements stored in contiguous memory locations, referred to by a single variable name and accessed using an index (subscript).

Syntax:

data_type array_name[size];

Example:

int marks[5];  /* declares an array of 5 integers */

2. Benefits of Using Array [2 marks]

3. Program to Add Two Matrices Using Array [7 marks]

Logic:

• Take two matrices A and B of the same size (r x c).
• Add corresponding elements: C[i][j] = A[i][j] + B[i][j]
• Display the resultant matrix C.

Program:

#include<stdio.h>
#include<conio.h>

void main()
{
    int A[10][10], B[10][10], C[10][10];
    int i, j, r, c;

    clrscr();

    /* Input: number of rows and columns */
    printf("Enter number of rows: ");
    scanf("%d", &r);

    printf("Enter number of columns: ");
    scanf("%d", &c);

    /* Input elements of Matrix A */
    printf("\nEnter elements of Matrix A:\n");
    for(i = 0; i < r; i++)
    {
        for(j = 0; j < c; j++)
        {
            printf("A[%d][%d] = ", i, j);
            scanf("%d", &A[i][j]);
        }
    }

    /* Input elements of Matrix B */
    printf("\nEnter elements of Matrix B:\n");
    for(i = 0; i < r; i++)
    {
        for(j = 0; j < c; j++)
        {
            printf("B[%d][%d] = ", i, j);
            scanf("%d", &B[i][j]);
        }
    }

    /* Addition of two matrices */
    for(i = 0; i < r; i++)
    {
        for(j = 0; j < c; j++)
        {
            C[i][j] = A[i][j] + B[i][j];
        }
    }

    /* Display the resultant matrix C */
    printf("\nResultant Matrix after Addition:\n");
    for(i = 0; i < r; i++)
    {
        for(j = 0; j < c; j++)
        {
            printf("%d\t", C[i][j]);
        }
        printf("\n");
    }

    getch();
}

Sample Output:

Enter number of rows: 2
Enter number of columns: 2

Enter elements of Matrix A:
A[0][0] = 1
A[0][1] = 2
A[1][0] = 3
A[1][1] = 4

Enter elements of Matrix B:
B[0][0] = 5
B[0][1] = 6
B[1][0] = 7
B[1][1] = 8

Resultant Matrix after Addition:
6       8
10      12

Explanation of Key Steps:

Data Files, File Opening Modes, and File Copy Program

(a) Why Do We Need Data Files?

When a program runs, all data is stored in main memory (RAM), which is volatile -- it is lost when the program ends or the computer is switched off. Data files solve this problem by providing permanent storage on secondary storage devices (hard disk, etc.).

Reasons we need data files:

• Persistence: Data stored in files remains even after the program terminates.
• Large data handling: Files allow processing of data too large to fit in memory at once.
• Data sharing: Multiple programs can read from and write to the same file.
• Reusability: Data entered once can be reused many times without re-entering.
• Record keeping: Files allow maintaining logs, reports, and databases permanently.

(b) Different File Opening Modes

As per the notes, the file opening modes used in C are:

(c) Program to Read from "input.txt" and Write to "output.txt"

Approach:

• Open input.txt in "r" (read) mode.
• Open output.txt in "w" (write) mode.
• Read characters one by one from input.txt using fgetc().
• Write each character to output.txt using fputc().
• Close both files after the operation.

#include <stdio.h>
#include <stdlib.h>

int main()
{
    FILE *fp_in, *fp_out;
    char ch;

    /* Open input.txt for reading */
    fp_in = fopen("input.txt", "r");
    if (fp_in == NULL)
    {
        printf("Error: Cannot open input.txt\n");
        exit(1);
    }

    /* Open output.txt for writing */
    fp_out = fopen("output.txt", "w");
    if (fp_out == NULL)
    {
        printf("Error: Cannot open output.txt\n");
        fclose(fp_in);
        exit(1);
    }

    /* Read from input.txt and write to output.txt character by character */
    while ((ch = fgetc(fp_in)) != EOF)
    {
        fputc(ch, fp_out);
    }

    printf("Data successfully copied from input.txt to output.txt\n");

    /* Close both files */
    fclose(fp_in);
    fclose(fp_out);

    return 0;
}

Explanation of Key Steps:

Sample Output:

Data successfully copied from input.txt to output.txt

The contents of input.txt will be completely copied into output.txt.

Preprocessor Directive and #define Directive

What is a Preprocessor Directive? [1.5 marks]

A preprocessor directive is an instruction given to the C preprocessor -- a program that processes the source code before actual compilation begins. Preprocessor directives tell the preprocessor to perform specific operations such as file inclusion, macro substitution, or conditional compilation.

Key characteristics:

• All preprocessor directives begin with the # (hash) symbol.
• They are not C statements, so they do not end with a semicolon (;).
• They are processed before the compiler translates the source code into object code.
• They appear at the top of the program, in the preprocessor directives section of the C program structure.

Common preprocessor directives:

The #define Directive [3.5 marks]

The #define directive is used to define macros in C. A macro is a name (identifier) that is replaced by a value or expression throughout the program by the preprocessor before compilation.

Syntax:

#define MACRO_NAME replacement_text

The preprocessor replaces every occurrence of MACRO_NAME in the source code with replacement_text before the compiler processes the file.

Types of #define Usage:

1. Symbolic Constants (Object-like Macros)

Used to define constant values. This improves readability and maintainability of the program -- if the value needs to change, it only needs to be changed in one place.

Example:

#include <stdio.h>
#define PI 3.14159
#define MAX 100

int main() {
    float radius, area;
    printf("Enter radius: ");
    scanf("%f", &radius);
    area = PI * radius * radius;
    printf("Area of circle = %.2f\n", area);
    return 0;
}

Output (for radius = 5):

Area of circle = 78.54

Here, every occurrence of PI is replaced by 3.14159 before compilation.

2. Function-like Macros (Macros with Parameters)

#define can also define macros that accept arguments, similar to functions but handled by the preprocessor.

Syntax:

#define MACRO_NAME(parameter) expression

Example:

#include <stdio.h>
#define SQUARE(x)   ((x) * (x))
#define MAX(a, b)   ((a) > (b) ? (a) : (b))

int main() {
    int num = 5;
    printf("Square of %d = %d\n", num, SQUARE(num));
    printf("Maximum of 10 and 20 = %d\n", MAX(10, 20));
    return 0;
}

Output:

Square of 5 = 25
Maximum of 10 and 20 = 20

Note: Parentheses around parameters in macros are important to avoid operator precedence errors. For example, SQUARE(2+3) without parentheses would give 2+3*2+3 = 11 (wrong), but with parentheses ((2+3)*(2+3)) = 25 (correct).

Important Points about #define:

Summary

The #define directive is a powerful preprocessor tool in C that allows programmers to define symbolic constants and function-like macros. It makes programs more readable, portable, and easy to maintain by avoiding the use of hard-coded values throughout the code.

Short Notes

a. Benefits of Data Files (2.5 marks)

A file is a collection of related data placed on the disk. C supports the concept of files through which data can be stored on a disk or secondary storage device, and the stored data can be read whenever required.

The key benefits of using data files are:

1. Permanent Storage of Data

Data stored in files is saved on the disk (secondary storage). Unlike variables stored in RAM, file data is not lost when the program terminates. It can be retrieved at any time.

2. Handling Large Amounts of Data

Files allow programs to process large volumes of data that cannot be held entirely in memory at once. Data can be read or written in parts (blocks, strings, characters, etc.).

3. Data Reusability

Once data is written to a file, it can be read and reused by the same program or different programs multiple times without re-entering the data.

4. Data Sharing Between Programs

Multiple programs can access the same data file, enabling easy sharing and transfer of information between different applications.

5. Easy Data Modification

Files can be opened in various modes such as "r+" (read + write / update mode) or "a+" (append + read) to modify or add new data without destroying existing data.

6. Organized Data Management

Data can be stored in a structured and organized manner. C provides various file modes ("r", "w", "a", "rb", "wb", etc.) and I/O functions (fread(), fwrite(), fprintf(), fscanf(), etc.) to manage data efficiently.

7. Buffered I/O for Efficiency

C file handling uses buffers to temporarily hold data during read/write operations. When a file is closed using fclose(), all buffered data is flushed (written) to the file, ensuring no data is lost and improving I/O performance.

b. Graphics Functions (2.5 marks)

C provides a graphics library (graphics.h) that allows drawing shapes, lines, and images on the screen using pixel-based coordinates. The origin pixel (0, 0) is located at the top-left corner of the screen.

The important graphics functions are:

1. initgraph(&gd, &gm, path)

• Purpose: Initializes the graphics system and puts the screen into graphics mode.
• gd = graphics driver, gm = graphics mode, path = path to BGI driver files.
• Example: initgraph(&gd, &gm, "c:\\tc\\bgi");

2. circle(x, y, radius)

• Purpose: Draws a circle with center at (x, y) and the given radius.
• Example: circle(300, 200, 150);

3. line(x1, y1, x2, y2)

• Purpose: Draws a line from point (x1, y1) to point (x2, y2) using pixels placed near each other.
• Coordinates are measured from the top-left corner of the screen.

4. getpixel(x, y)

• Purpose: Gets the color of the pixel at position (x, y).
• Returns an integer value corresponding to the color of that pixel.
• The pixel is the smallest element on the graphics display screen.

5. setcolor(color)

• Purpose: Sets the current drawing color for subsequent graphics operations.
• Example: setcolor(WHITE);

6. closegraph()

• Purpose: Closes the graphics mode and restores the screen to text mode, freeing resources used by the graphics system.

Example Program (from notes):

#include<stdio.h>
#include<conio.h>
#include<graphics.h>
void main()
{
    int gd = DETECT, gm;
    initgraph(&gd, &gm, "c:\\tc\\bgi");
    circle(300, 200, 150);
    setcolor(WHITE);
    getch();
    closegraph();
}

Note: In C graphics, images are formed by placing pixels (dots) near each other on the screen. The pixel at position (0, 0) is always at the top-left corner of the screen.