C Programming

An algorithm is a finite, step-by-step set of well-defined instructions for solving a problem or accomplishing a task. It takes input, produces output, and should be clear, unambiguous and terminate after a finite number of steps.

A preprocessor directive is an instruction in C that begins with # and is processed by the preprocessor before actual compilation begins. Examples are #include <stdio.h> to include a header file and #define PI 3.14 to define a macro.

The conditional operator ?: is the only ternary operator in C (it takes three operands). It is a short form of if-else.

Syntax: expression1 ? expression2 : expression3;

If expression1 is true (non-zero), expression2 is evaluated; otherwise expression3 is evaluated.

max = (a > b) ? a : b;

A two-dimensional array is initialized by giving the values row by row inside braces, with the data type, name and both sizes declared.

int a[2][3] = { {1, 2, 3}, {4, 5, 6} };

It may also be written as int a[2][3] = {1, 2, 3, 4, 5, 6};. The first dimension may be omitted when initializing, e.g. int a[][3] = {{1,2,3},{4,5,6}};. Elements can also be assigned or read with nested loops.

A function prototype is a declaration of a function that tells the compiler its name, return type and the number and types of its parameters before the function is used or defined. It ends with a semicolon.

int add(int, int);

It allows the compiler to check that calls match the function's definition.

A double pointer (pointer to pointer), declared as int **pp;, stores the address of another pointer variable. Its uses are:

• To modify a pointer itself from inside a function (pass the pointer's address).
• To create dynamic 2D arrays and arrays of strings (e.g. char **names).
• To handle command-line arguments (char **argv).

int x = 5, *p = &x, **pp = &p;
printf("%d", **pp);   /* 5 */

The modes used with fopen() are:

• r - open an existing file for reading.
• w - open for writing; creates the file or erases an existing one.
• a - open for appending at the end of the file.
• r+ - open an existing file for reading and writing.
• w+ - open for reading and writing; erases existing content.
• a+ - open for reading and appending.
• Adding b (e.g. rb, wb) opens the file in binary mode.

#include <stdio.h>

int main() {
    int n;
    printf("Enter a number: ");
    scanf("%d", &n);

    if (n % 5 == 0 || n % 7 == 0)
        printf("%d is divisible by 5 or 7.\n", n);
    else
        printf("%d is not divisible by 5 or 7.\n", n);
    return 0;
}

A number is divisible by 5 or 7 if the remainder (%) on division by either is zero.

#include <stdio.h>

int main() {
    int n, i = 1, sum = 0;
    printf("Enter n: ");
    scanf("%d", &n);

    while (i <= n) {
        sum = sum + i * i * i;
        i++;
    }
    printf("Sum of cubes = %d\n", sum);
    return 0;
}

For $n = 3$: $1^3 + 2^3 + 3^3 = 1 + 8 + 27 = 36$, which is printed.

#include <stdio.h>
#include <ctype.h>

int main() {
    char line[200];
    int i, count = 0;
    printf("Enter a line of text: ");
    fgets(line, sizeof(line), stdin);

    for (i = 0; line[i] != '\0'; i++) {
        switch (tolower(line[i])) {
            case 'a': case 'e': case 'i': case 'o': case 'u':
                count++;
        }
    }
    printf("Number of vowels = %d\n", count);
    return 0;
}

#include <stdio.h>

int main() {
    char str[100];
    int len = 0;
    printf("Enter a string: ");
    scanf("%99[^\n]", str);

    while (str[len] != '\0')
        len++;

    printf("Length of the string = %d\n", len);
    return 0;
}

The loop counts characters until the null character '\0'. (The library function strlen(str) gives the same result.)

#include <stdio.h>

long fact(int n) {
    if (n == 0 || n == 1)
        return 1;
    return n * fact(n - 1);
}

int main() {
    int n;
    printf("Enter a number: ");
    scanf("%d", &n);
    if (n < 0)
        printf("Factorial is not defined for negative numbers.\n");
    else
        printf("Factorial of %d = %ld\n", n, fact(n));
    return 0;
}

The function calls itself with $n-1$ until the base case $n = 1$ (or $0$) is reached, since $n! = n \times (n-1)!$.

#include <graphics.h>
#include <conio.h>

int main() {
    int gd = DETECT, gm;
    initgraph(&gd, &gm, "C:\\TC\\BGI");

    line(200, 100, 100, 250);   /* left side  */
    line(200, 100, 300, 250);   /* right side */
    line(100, 250, 300, 250);   /* base       */

    getch();
    closegraph();
    return 0;
}

initgraph() starts graphics mode, line(x1, y1, x2, y2) draws a line between two points, and closegraph() returns to text mode.

Logical operators combine or negate conditions (relational expressions) and give a result of 1 (true) or 0 (false). C has three logical operators.

(a) Logical AND (&&) - true only if both operands are true.

(b) Logical OR (||) - true if at least one operand is true.

(c) Logical NOT (!) - unary operator that reverses the truth value of its operand.

int a = 10, b = 20, c = 5;
if (a > c && b > a)  printf("both true\n");     /* printed */
if (a > b || c > 1)  printf("one true\n");      /* printed */
if (!(a > b))        printf("not (a>b)\n");     /* printed */

&& and || use short-circuit evaluation: in A && B, B is not evaluated if A is false; in A || B, B is not evaluated if A is true. Any non-zero value is treated as true.

An array is passed to a function by passing its name, which is the address of its first element (call by reference). The formal parameter can be written as an array (int a[], int a[5]) or a pointer (int *a). The size is usually passed as another argument. Because the address is passed, changes made in the function affect the original array.

#include <stdio.h>

int sum(int a[], int n) {
    int i, s = 0;
    for (i = 0; i < n; i++)
        s += a[i];
    return s;
}

int main() {
    int arr[5] = {1, 2, 3, 4, 5};
    printf("Sum = %d\n", sum(arr, 5));   /* Sum = 15 */
    return 0;
}

For a 2D array, all dimensions except the first must be given in the parameter, e.g. void show(int m[][3], int r).

Dynamic memory allocation is allocating memory at run time (from the heap) as needed, instead of fixing the size at compile time. It is declared in <stdlib.h>.

malloc() - allocates a block of the given number of bytes and returns a void pointer to it (or NULL on failure). The memory is not initialized.

ptr = (int *) malloc(n * sizeof(int));

free() - releases memory previously allocated, returning it to the system and avoiding memory leaks.

free(ptr);

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

int main() {
    int n, i, *p;
    printf("How many numbers? ");
    scanf("%d", &n);

    p = (int *) malloc(n * sizeof(int));
    if (p == NULL) {
        printf("Memory not available\n");
        return 1;
    }
    for (i = 0; i < n; i++)
        scanf("%d", p + i);
    for (i = 0; i < n; i++)
        printf("%d ", *(p + i));

    free(p);
    return 0;
}

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

int main() {
    FILE *fn, *fp, *fneg;
    int n, i, x;

    fn = fopen("Number.txt", "w");
    if (fn == NULL) { printf("Cannot open file\n"); exit(1); }
    printf("How many numbers? ");
    scanf("%d", &n);
    printf("Enter %d numbers: ", n);
    for (i = 0; i < n; i++) {
        scanf("%d", &x);
        fprintf(fn, "%d\n", x);
    }
    fclose(fn);

    fn   = fopen("Number.txt", "r");
    fp   = fopen("Positive.txt", "w");
    fneg = fopen("Negative.txt", "w");
    if (fn == NULL || fp == NULL || fneg == NULL) {
        printf("Cannot open file\n");
        exit(1);
    }
    while (fscanf(fn, "%d", &x) == 1) {
        if (x > 0)
            fprintf(fp, "%d\n", x);
        else if (x < 0)
            fprintf(fneg, "%d\n", x);
    }
    fclose(fn);
    fclose(fp);
    fclose(fneg);
    return 0;
}

Zero is neither positive nor negative, so it is written to neither file.

Why looping is used: A loop repeats a block of statements as long as a condition holds. It avoids writing the same code many times, makes programs shorter and easier to maintain, and is needed for processing arrays, files, tables and menus.

C provides three looping statements.

(a) while loop (entry-controlled) - the condition is tested first; the body runs only while it is true.

i = 1;
while (i <= 5) {
    printf("%d ", i);
    i++;
}

(b) do-while loop (exit-controlled) - the body runs first, then the condition is tested, so it executes at least once.

i = 1;
do {
    printf("%d ", i);
    i++;
} while (i <= 5);

(c) for loop - initialization, condition and update are written together in one line.

for (i = 1; i <= 5; i++)
    printf("%d ", i);

Each of these prints 1 2 3 4 5.

Syntax summary

Loops can be nested (a loop inside another), e.g. printing a pattern:

for (i = 1; i <= 3; i++) {
    for (j = 1; j <= i; j++)
        printf("*");
    printf("\n");
}

Jump statements break (leave the loop) and continue (skip to the next iteration) control loop execution. An infinite loop such as for(;;) runs until a break or exit().

Structure: A structure is a user-defined data type that groups variables of different data types under one name, declared with the struct keyword. Each variable is a member, and each member has its own memory.

struct Student {
    char name[30];
    int roll_number;
    float percentage;
};

Difference between structure and union

Program

#include <stdio.h>

struct Student {
    char name[30];
    int roll_number;
    float percentage;
};

int main() {
    struct Student s[100];
    int n, i;
    printf("Enter number of students: ");
    scanf("%d", &n);

    for (i = 0; i < n; i++) {
        printf("Student %d name: ", i + 1);
        scanf("%29s", s[i].name);
        printf("Roll number: ");
        scanf("%d", &s[i].roll_number);
        printf("Percentage: ");
        scanf("%f", &s[i].percentage);
    }

    printf("\nStudents with percentage >= 80:\n");
    for (i = 0; i < n; i++) {
        if (s[i].percentage >= 80)
            printf("%s\n", s[i].name);
    }
    return 0;
}