Basics and Introduction to C

1.1 History of C

The C programming language was developed by Dennis Ritchie at Bell Laboratories (AT&T) in 1972. It evolved from two earlier languages — BCPL (Basic Combined Programming Language, by Martin Richards, 1967) and B (by Ken Thompson, 1970). C was originally designed to re-implement the UNIX operating system, which had previously been written in assembly language.

1.2 Features of C

• Middle-level language — combines features of high-level and low-level languages
• Structured programming — supports functions and blocks
• Portability — C programs can be compiled on different platforms with minimal changes
• Rich operator set — arithmetic, bitwise, logical, relational, and more
• Pointers — direct memory access and manipulation
• Fast execution — compiled to machine code, close to hardware
• Extensible — new functions can be added to the library
• Recursion — functions can call themselves

1.3 Applications of C

C is used to build: Operating systems (Linux, Windows kernel), Embedded systems (microcontrollers, IoT), Compilers (GCC), Database engines (MySQL, PostgreSQL), Game engines, Device drivers, and Networking tools.

1.4 Structure of a C Program

C
/* Documentation Section (optional) */
/* Preprocessor Directives */
#include <stdio.h>

/* Global Declarations (optional) */
int globalVar = 10;

/* Main Function */
int main() {
    /* Local Declarations */
    int a = 5;

    /* Executable Statements */
    printf("Hello, World!\n");

    return 0;
}

/* User-defined Functions (optional) */

1.5 The C Character Set

1.6 Identifiers and Naming Rules

An identifier is a name given to variables, functions, arrays, or any user-defined item. Rules:

• Must begin with a letter (A-Z, a-z) or underscore (_)
• Can contain letters, digits (0-9), and underscores
• Cannot start with a digit
• Cannot use C keywords as identifiers
• C is case-sensitive: age and Age are different
• No limit on length (but first 31 characters are significant in C89)

1.7 Keywords in C

C has 32 reserved keywords (C89/C90). These cannot be used as identifiers.

1.8 Data Types

C provides several fundamental data types. The size may vary by platform; the table below shows typical sizes on a 32/64-bit system.

C
#include <stdio.h>

int main() {
    printf("Size of char:        %zu byte\n", sizeof(char));
    printf("Size of int:         %zu bytes\n", sizeof(int));
    printf("Size of float:       %zu bytes\n", sizeof(float));
    printf("Size of double:      %zu bytes\n", sizeof(double));
    printf("Size of long long:   %zu bytes\n", sizeof(long long));
    return 0;
}

1.9 Constants

Integer Constants

Decimal: 42, Octal (prefix 0): 052, Hexadecimal (prefix 0x): 0x2A

Suffixes: 10L (long), 10U (unsigned), 10UL (unsigned long), 10LL (long long)

Floating-Point Constants

3.14, 2.0e5 (= 200000.0), 1.5E-3 (= 0.0015). Default type is double; suffix f for float: 3.14f

Character Constants

A single character in single quotes: 'A', '9', '$'. Stored as ASCII integer value.

String Constants

A sequence of characters in double quotes: "Hello". Automatically terminated with \0.

1.10 Variables

A variable is a named location in memory that holds a value which can change during program execution.

C
int age = 21;              // Declaration + Initialization
float gpa;                   // Declaration only (contains garbage)
gpa = 8.75;                 // Assignment
char grade = 'A';          // Character variable
const int MAX = 100;       // Constant — cannot be changed

1.11 Expressions and Statements

An expression is a combination of variables, constants, and operators that evaluates to a value: a + b * c. A statement is a complete instruction ending with a semicolon: x = a + b;

1.12 Arithmetic Operators

C
#include <stdio.h>

int main() {
    int a = 17, b = 5;
    printf("a + b = %d\n", a + b);
    printf("a - b = %d\n", a - b);
    printf("a * b = %d\n", a * b);
    printf("a / b = %d\n", a / b);       // Integer division
    printf("a %% b = %d\n", a % b);
    printf("a / b = %.2f\n", (float)a / b);  // Float division
    return 0;
}

1.13 Unary Operators

C
#include <stdio.h>

int main() {
    int a = 5, b, c;

    b = ++a;   // Pre: a becomes 6, then b = 6
    printf("After ++a: a=%d, b=%d\n", a, b);

    a = 5;
    c = a++;   // Post: c = 5, then a becomes 6
    printf("After a++: a=%d, c=%d\n", a, c);

    printf("!0 = %d, !5 = %d\n", !0, !5);
    printf("~0 = %d\n", ~0);
    return 0;
}

1.14 Relational Operators

Relational operators compare two values and return 1 (true) or 0 (false).

1.15 Logical Operators

1.16 Assignment Operators

1.17 Conditional (Ternary) Operator

C
int a = 10, b = 20;
int max = (a > b) ? a : b;   // max = 20
printf("Max = %d\n", max);

// Equivalent to:
if (a > b) max = a;
else max = b;

1.18 Bitwise Operators

Bitwise operators work on individual bits of integer values.

C
#include <stdio.h>

int main() {
    int a = 5, b = 3;  // a = 0101, b = 0011
    printf("a & b  = %d\n", a & b);   // 0001 = 1
    printf("a | b  = %d\n", a | b);   // 0111 = 7
    printf("a ^ b  = %d\n", a ^ b);   // 0110 = 6
    printf("~a     = %d\n", ~a);      // -6
    printf("a << 1 = %d\n", a << 1);  // 1010 = 10
    printf("a >> 1 = %d\n", a >> 1);  // 0010 = 2
    return 0;
}

1.19 Operator Precedence and Associativity

1.20 Type Casting

Implicit Casting (Widening / Type Promotion)

C automatically converts a smaller type to a larger type: char → int → long → float → double

C
int x = 10;
float y = 3.5;
float result = x + y;  // x is promoted to float: 10.0 + 3.5 = 13.5

Explicit Casting (Narrowing)

C
float pi = 3.14159;
int truncated = (int)pi;    // truncated = 3 (decimal lost!)

int a = 7, b = 2;
float div = (float)a / b;  // 7.0 / 2 = 3.5 (not 3!)

C
#include <stdio.h>

int main() {
    float celsius, fahrenheit;
    int choice;

    printf("=== Temperature Converter ===\n");
    printf("1. Celsius to Fahrenheit\n");
    printf("2. Fahrenheit to Celsius\n");
    printf("Enter choice: ");
    scanf("%d", &choice);

    if (choice == 1) {
        printf("Enter Celsius: ");
        scanf("%f", &celsius);
        fahrenheit = (celsius * 9.0 / 5.0) + 32;
        printf("%.2f°C = %.2f°F\n", celsius, fahrenheit);
    } else if (choice == 2) {
        printf("Enter Fahrenheit: ");
        scanf("%f", &fahrenheit);
        celsius = (fahrenheit - 32) * 5.0 / 9.0;
        printf("%.2f°F = %.2f°C\n", fahrenheit, celsius);
    }
    return 0;
}

C
#include <stdio.h>

int main() {
    double a, b, result;
    char op;

    printf("Enter expression (e.g. 5 + 3): ");
    scanf("%lf %c %lf", &a, &op, &b);

    switch (op) {
        case '+': result = a + b; break;
        case '-': result = a - b; break;
        case '*': result = a * b; break;
        case '/':
            if (b != 0) result = a / b;
            else { printf("Error: Division by zero!\n"); return 1; }
            break;
        case '%': result = (int)a % (int)b; break;
        default: printf("Invalid operator!\n"); return 1;
    }
    printf("%.2lf %c %.2lf = %.2lf\n", a, op, b, result);
    return 0;
}

C
#include <stdio.h>

// Device status flags (each bit = one flag)
#define FLAG_POWER    (1 << 0)  // Bit 0: 0x01
#define FLAG_WIFI     (1 << 1)  // Bit 1: 0x02
#define FLAG_BLUETOOTH (1 << 2) // Bit 2: 0x04
#define FLAG_GPS      (1 << 3)  // Bit 3: 0x08
#define FLAG_ERROR    (1 << 7)  // Bit 7: 0x80

void printStatus(unsigned char reg) {
    printf("Status: Power=%d WiFi=%d BT=%d GPS=%d Error=%d\n",
        (reg & FLAG_POWER) ? 1 : 0,
        (reg & FLAG_WIFI) ? 1 : 0,
        (reg & FLAG_BLUETOOTH) ? 1 : 0,
        (reg & FLAG_GPS) ? 1 : 0,
        (reg & FLAG_ERROR) ? 1 : 0);
}

int main() {
    unsigned char deviceReg = 0x00;  // All off

    // SET flags (turn ON): use OR
    deviceReg |= FLAG_POWER;
    deviceReg |= FLAG_WIFI;
    printf("After power + wifi ON:\n");
    printStatus(deviceReg);

    // CLEAR a flag (turn OFF): use AND NOT
    deviceReg &= ~FLAG_WIFI;
    printf("After wifi OFF:\n");
    printStatus(deviceReg);

    // TOGGLE a flag: use XOR
    deviceReg ^= FLAG_GPS;
    printf("After GPS toggle:\n");
    printStatus(deviceReg);

    // CHECK a flag
    if (deviceReg & FLAG_POWER)
        printf("Device is powered ON\n");
    return 0;
}

Control Structures and I/O Functions

In Chapter 1 you learned how to store data in variables and perform arithmetic. But programs that simply execute one statement after another, top-to-bottom, are of limited use. Real software must make decisions ("Is the password correct?"), repeat actions ("Keep reading sensor data until shutdown"), and communicate with the user through formatted input and output. This chapter gives you full mastery over C's decision-making statements, looping constructs, jump statements, type conversions, and every standard I/O function you will encounter in practice.

2.1 Decision-Making Statements

Every non-trivial program needs to choose among alternatives. C provides four primary decision constructs: if, if-else, the else-if ladder, and switch-case. All of them evaluate an expression and execute a block of code only when the expression is non-zero (true).

2.1.1 The if Statement

Syntax:

C
if (condition) {
    // executed only when condition is non-zero (true)
    statement1;
    statement2;
}

How it works (flowchart description):

1. The condition expression is evaluated.
2. If the result is non-zero (true), control enters the block inside the braces.
3. If the result is zero (false), the block is skipped entirely and execution continues with the next statement after the closing brace.
4. After the block executes (or is skipped), the program continues sequentially.

Example — Checking voting eligibility:

C
#include <stdio.h>

int main(void) {
    int age;
    printf("Enter your age: ");
    scanf("%d", &age);

    if (age >= 18) {
        printf("You are eligible to vote.\n");
    }

    printf("Thank you for using the system.\n");
    return 0;
}

2.1.2 The if-else Statement

When you need to do one thing if a condition is true and a different thing if it is false, use if-else.

C
if (condition) {
    // true block
} else {
    // false block
}

Example — Odd or Even:

C
#include <stdio.h>

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

    if (num % 2 == 0) {
        printf("%d is even.\n", num);
    } else {
        printf("%d is odd.\n", num);
    }

    return 0;
}

2.1.3 Nested if-else

An if or else block may itself contain another if-else, creating a nested structure. This is useful when a decision depends on more than one condition.

C
#include <stdio.h>

int main(void) {
    int a = 10, b = 20, c = 15;

    if (a >= b) {
        if (a >= c)
            printf("Largest = %d\n", a);
        else
            printf("Largest = %d\n", c);
    } else {
        if (b >= c)
            printf("Largest = %d\n", b);
        else
            printf("Largest = %d\n", c);
    }

    return 0;
}

2.1.4 The else-if Ladder

When you must choose among many mutually exclusive conditions, chain else if clauses to form a ladder. Conditions are evaluated from top to bottom; the first one that is true causes its block to execute, and the rest are skipped.

C
if (condition1) {
    // block 1
} else if (condition2) {
    // block 2
} else if (condition3) {
    // block 3
} else {
    // default block (none of the above)
}

C
#include <stdio.h>

int main(void) {
    float marks;
    printf("Enter percentage marks: ");
    scanf("%f", &marks);

    if (marks < 0 || marks > 100) {
        printf("Invalid marks! Must be 0-100.\n");
    } else if (marks >= 90) {
        printf("Grade: A+ (Outstanding)\n");
    } else if (marks >= 80) {
        printf("Grade: A  (Excellent)\n");
    } else if (marks >= 70) {
        printf("Grade: B  (Good)\n");
    } else if (marks >= 60) {
        printf("Grade: C  (Average)\n");
    } else if (marks >= 50) {
        printf("Grade: D  (Below Average)\n");
    } else {
        printf("Grade: F  (Fail)\n");
    }

    return 0;
}

2.1.5 The switch-case Statement

When a single integer or character expression must be tested against several constant values, switch is often cleaner than a long else-if ladder.

C
switch (expression) {
    case constant1:
        // statements
        break;
    case constant2:
        // statements
        break;
    /* ... more cases ... */
    default:
        // executed if no case matches
        break;
}

Key rules:

• The expression must evaluate to an integer type (int, char, short, long, enum). Floating-point and strings are not allowed.
• Each case label must be a compile-time constant (literal or const/#define).
• No two cases may have the same value.
• break transfers control out of the switch. Without it, execution falls through to the next case.
• default is optional but strongly recommended.

Fall-through behavior (deliberate use):

C
#include <stdio.h>

int main(void) {
    char grade;
    printf("Enter grade (A/B/C/D/F): ");
    scanf(" %c", &grade);  // note the space before %c

    switch (grade) {
        case 'A':
        case 'a':     // fall-through: both 'A' and 'a' handled alike
            printf("Excellent!\n");
            break;
        case 'B':
        case 'b':
            printf("Good job!\n");
            break;
        case 'C':
        case 'c':
            printf("Satisfactory.\n");
            break;
        case 'F':
        case 'f':
            printf("You need to improve.\n");
            break;
        default:
            printf("Invalid grade entered.\n");
    }
    return 0;
}

Integer case example — Simple calculator:

C
#include <stdio.h>

int main(void) {
    double a, b;
    char op;
    printf("Enter expression (e.g., 5 + 3): ");
    scanf("%lf %c %lf", &a, &op, &b);

    switch (op) {
        case '+': printf("= %.2f\n", a + b); break;
        case '-': printf("= %.2f\n", a - b); break;
        case '*': printf("= %.2f\n", a * b); break;
        case '/':
            if (b != 0)
                printf("= %.2f\n", a / b);
            else
                printf("Error: Division by zero!\n");
            break;
        default:
            printf("Unknown operator '%c'\n", op);
    }
    return 0;
}

2.2 Loop Constructs

Loops allow a block of code to be executed repeatedly as long as a condition remains true. C provides three loop constructs: while, for, and do-while.

2.2.1 The while Loop

Syntax:

C
while (condition) {
    // loop body
    // must include something that eventually makes condition false!
}

The condition is tested before each iteration (entry-controlled loop). If the condition is false initially, the body never executes.

Counter-controlled example — Print 1 to N:

C
#include <stdio.h>

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

    while (i <= n) {
        printf("%d ", i);
        i++;
    }
    printf("\n");
    return 0;
}

Sentinel-controlled example — Sum until user enters -1:

C
#include <stdio.h>

int main(void) {
    int num, sum = 0;
    printf("Enter numbers (-1 to stop): ");
    scanf("%d", &num);

    while (num != -1) {
        sum += num;
        scanf("%d", &num);
    }

    printf("Sum = %d\n", sum);
    return 0;
}

2.2.2 The for Loop

The for loop is the most versatile and commonly used loop in C. It bundles initialization, condition-checking, and update into one line.

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

Execution sequence:

1. initialization — executed once before the loop starts.
2. condition — checked before each iteration. If false, the loop ends.
3. body — executed if condition is true.
4. update — executed after the body, then control returns to step 2.

Basic example — Factorial:

C
#include <stdio.h>

int main(void) {
    int n;
    long long fact = 1;
    printf("Enter a positive integer: ");
    scanf("%d", &n);

    for (int i = 1; i <= n; i++) {
        fact *= i;
    }
    printf("%d! = %lld\n", n, fact);
    return 0;
}

Variations of the for loop:

C
/* 1. Multiple initializations and updates (using comma operator) */
for (int i = 0, j = 10; i < j; i++, j--) {
    printf("i=%d, j=%d\n", i, j);
}

/* 2. Empty initialization (variable declared outside) */
int k = 0;
for ( ; k < 5; k++) {
    printf("%d ", k);
}

/* 3. Empty condition — infinite loop (must break manually) */
for ( ; ; ) {
    printf("Infinite loop! Press Ctrl+C.\n");
    break;  // added to prevent actual infinite loop in example
}

/* 4. Empty body (all work in the header) */
int sum = 0;
for (int i = 1; i <= 100; sum += i, i++)
    ;  // null statement — sum = 5050 after loop

2.2.3 The do-while Loop

The do-while loop is an exit-controlled loop — the body is guaranteed to execute at least once because the condition is checked after the body.

C
do {
    // loop body — executes at least once
} while (condition);  // note the semicolon!

Key difference from while: A while loop may execute zero times if the condition is initially false. A do-while always runs the body at least once.

C
#include <stdio.h>

int main(void) {
    int choice;
    double balance = 50000.00, amount;

    do {
        printf("\n====== ATM MENU ======\n");
        printf("1. Check Balance\n");
        printf("2. Deposit\n");
        printf("3. Withdraw\n");
        printf("4. Exit\n");
        printf("Enter choice: ");
        scanf("%d", &choice);

        switch (choice) {
            case 1:
                printf("Balance: Rs. %.2f\n", balance);
                break;
            case 2:
                printf("Enter deposit amount: ");
                scanf("%lf", &amount);
                if (amount > 0) {
                    balance += amount;
                    printf("Deposited. New balance: Rs. %.2f\n", balance);
                } else {
                    printf("Invalid amount.\n");
                }
                break;
            case 3:
                printf("Enter withdrawal amount: ");
                scanf("%lf", &amount);
                if (amount > 0 && amount <= balance) {
                    balance -= amount;
                    printf("Withdrawn. New balance: Rs. %.2f\n", balance);
                } else {
                    printf("Insufficient funds or invalid amount.\n");
                }
                break;
            case 4:
                printf("Thank you for banking with us!\n");
                break;
            default:
                printf("Invalid choice. Try again.\n");
        }
    } while (choice != 4);

    return 0;
}

2.3 Nested Loops & Pattern Printing

A loop placed inside another loop is called a nested loop. The inner loop completes all its iterations for each single iteration of the outer loop. Pattern printing is the most effective way to understand nested loops.

2.3.1 Multiplication Table

C
#include <stdio.h>

int main(void) {
    int n = 10;
    for (int i = 1; i <= n; i++) {
        for (int j = 1; j <= n; j++) {
            printf("%4d", i * j);
        }
        printf("\n");
    }
    return 0;
}

   1   2   3   4   5   6   7   8   9  10
   2   4   6   8  10  12  14  16  18  20
   3   6   9  12  15  18  21  24  27  30
   4   8  12  16  20  24  28  32  36  40
   5  10  15  20  25  30  35  40  45  50
   ...

2.3.2 Right Triangle (Stars)

C
/*  Pattern (n=5):
    *
    **
    ***
    ****
    *****
*/
#include <stdio.h>

int main(void) {
    int n = 5;
    for (int i = 1; i <= n; i++) {
        for (int j = 1; j <= i; j++) {
            printf("*");
        }
        printf("\n");
    }
    return 0;
}

*
**
***
****
*****

2.3.3 Inverted Right Triangle

C
/*  Pattern (n=5):
    *****
    ****
    ***
    **
    *
*/
#include <stdio.h>

int main(void) {
    int n = 5;
    for (int i = n; i >= 1; i--) {
        for (int j = 1; j <= i; j++) {
            printf("*");
        }
        printf("\n");
    }
    return 0;
}

*****
****
***
**
*

2.3.4 Pyramid (Centered Triangle)

C
/*  Pattern (n=5):
        *
       ***
      *****
     *******
    *********
*/
#include <stdio.h>

int main(void) {
    int n = 5;
    for (int i = 1; i <= n; i++) {
        // print leading spaces
        for (int j = 1; j <= n - i; j++)
            printf(" ");
        // print stars
        for (int j = 1; j <= 2 * i - 1; j++)
            printf("*");
        printf("\n");
    }
    return 0;
}

    *
   ***
  *****
 *******
*********

2.3.5 Inverted Pyramid

C
#include <stdio.h>

int main(void) {
    int n = 5;
    for (int i = n; i >= 1; i--) {
        for (int j = 1; j <= n - i; j++)
            printf(" ");
        for (int j = 1; j <= 2 * i - 1; j++)
            printf("*");
        printf("\n");
    }
    return 0;
}

*********
 *******
  *****
   ***
    *

2.3.6 Diamond Pattern

C
#include <stdio.h>

int main(void) {
    int n = 5;

    // Upper half (including middle row)
    for (int i = 1; i <= n; i++) {
        for (int j = 1; j <= n - i; j++) printf(" ");
        for (int j = 1; j <= 2 * i - 1; j++) printf("*");
        printf("\n");
    }
    // Lower half
    for (int i = n - 1; i >= 1; i--) {
        for (int j = 1; j <= n - i; j++) printf(" ");
        for (int j = 1; j <= 2 * i - 1; j++) printf("*");
        printf("\n");
    }

    return 0;
}

    *
   ***
  *****
 *******
*********
 *******
  *****
   ***
    *

2.3.7 Floyd's Triangle

C
/*  Floyd's Triangle (n=5 rows):
    1
    2  3
    4  5  6
    7  8  9  10
    11 12 13 14 15
*/
#include <stdio.h>

int main(void) {
    int n = 5, num = 1;
    for (int i = 1; i <= n; i++) {
        for (int j = 1; j <= i; j++) {
            printf("%-4d", num++);
        }
        printf("\n");
    }
    return 0;
}

1
2   3
4   5   6
7   8   9   10
11  12  13  14  15

2.3.8 Number Pyramid

C
/*  Pattern (n=5):
        1
       1 2
      1 2 3
     1 2 3 4
    1 2 3 4 5
*/
#include <stdio.h>

int main(void) {
    int n = 5;
    for (int i = 1; i <= n; i++) {
        for (int j = 1; j <= n - i; j++)
            printf(" ");
        for (int j = 1; j <= i; j++)
            printf("%d ", j);
        printf("\n");
    }
    return 0;
}

    1
   1 2
  1 2 3
 1 2 3 4
1 2 3 4 5

2.4 Jump Statements

Jump statements transfer control unconditionally to another point in the program.

2.4.1 The break Statement

break terminates the innermost enclosing loop or switch. Control passes to the statement immediately after the terminated construct.

C
/* Find first number divisible by 7 in range 100-200 */
#include <stdio.h>

int main(void) {
    for (int i = 100; i <= 200; i++) {
        if (i % 7 == 0) {
            printf("First divisible by 7: %d\n", i);
            break;  // exit the for loop immediately
        }
    }
    return 0;
}

2.4.2 The continue Statement

continue skips the rest of the current iteration and jumps to the condition check (for while/do-while) or the update expression (for for).

C
/* Print odd numbers from 1 to 20 */
#include <stdio.h>

int main(void) {
    for (int i = 1; i <= 20; i++) {
        if (i % 2 == 0)
            continue;  // skip even numbers
        printf("%d ", i);
    }
    printf("\n");
    return 0;
}

2.4.3 The goto Statement and Labels

goto transfers control to a labeled statement anywhere within the same function.

C
goto label_name;
/* ... */
label_name:
    statement;

C
/* Acceptable use: centralized cleanup */
#include <stdio.h>
#include <stdlib.h>

int process_data(void) {
    int *buf1 = malloc(100);
    if (!buf1) goto fail1;

    int *buf2 = malloc(200);
    if (!buf2) goto fail2;

    /* ... do work with buf1 and buf2 ... */

    free(buf2);
    free(buf1);
    return 0;

fail2:
    free(buf1);
fail1:
    return -1;
}

2.4.4 The return Statement

return terminates the current function and optionally passes a value back to the caller. In main(), return 0; signals successful program termination to the OS, while a non-zero value indicates an error.

C
return;          // for void functions
return expression; // for non-void functions

2.5 Type Conversion

2.5.1 Implicit (Automatic) Type Conversion — Widening

When an expression contains operands of different types, C automatically promotes the "narrower" type to the "wider" type. This is called implicit conversion or type promotion. The hierarchy (from narrow to wide) is:

char → short → int → unsigned int → long → unsigned long → long long → float → double → long double

C
int a = 5;
double b = 2.5;
double result = a + b;  // 'a' is promoted to double → 7.5

char ch = 'A';          // ASCII 65
int val = ch + 1;       // ch promoted to int → val = 66

2.5.2 Explicit Type Casting

You can force a conversion using the cast operator:

C
(target_type) expression

C
int a = 7, b = 2;
double result;

result = a / b;             // integer division → 3.000000
result = (double) a / b;    // a cast to double → 3.500000

printf("Without cast: %f\n", (double)(a / b));  // 3.000000
printf("With cast:    %f\n", (double)a / b);    // 3.500000

2.5.3 Type Modifiers and Their Ranges

C provides type modifiers that change the size and/or sign of basic integer types. The exact sizes are implementation-defined, but the C standard guarantees minimum ranges. Typical sizes on a modern 64-bit system:

C
#include <stdio.h>
#include <limits.h>

int main(void) {
    printf("int:       %d to %d\n", INT_MIN, INT_MAX);
    printf("unsigned:  0 to %u\n", UINT_MAX);
    printf("short:     %d to %d\n", SHRT_MIN, SHRT_MAX);
    printf("long long: %lld to %lld\n", LLONG_MIN, LLONG_MAX);
    return 0;
}

2.6 Designing Structured Programs

Structured programming is a paradigm that restricts programs to three control structures: sequence, selection, and iteration. The Böhm-Jacopini theorem (1966) proved that any computable algorithm can be expressed using only these three structures — no goto needed.

Top-Down Design

Start with the overall problem, break it into sub-problems, and continue decomposing until each sub-problem is simple enough to code in a few lines. This produces a hierarchy of modules (functions in C).

Modular Design Principles

• Single Responsibility: Each function should do exactly one thing.
• Small Functions: Aim for functions under ~30 lines.
• Meaningful Names: calculate_tax() beats ct().
• Avoid Global Variables: Pass data through parameters and return values.
• Comment contracts: Document what a function expects and what it returns.

2.7 Formatted I/O — printf() and scanf()

2.7.1 printf() — Formatted Output

printf() writes formatted data to stdout. Its prototype is: int printf(const char *format, ...);

Complete table of format specifiers:

Width, Precision, and Flags

Format specifier syntax: %[flags][width][.precision]specifier

Comprehensive printf() example:

C
#include <stdio.h>

int main(void) {
    int    n = 255;
    double pi = 3.14159265358979;
    char   ch = 'Z';
    char   name[] = "Computer Science";

    printf("Decimal:     %d\n", n);          // 255
    printf("Octal:       %o\n", n);          // 377
    printf("Hex (lower): %x\n", n);          // ff
    printf("Hex (upper): %X\n", n);          // FF
    printf("Unsigned:    %u\n", n);          // 255

    printf("Float:       %f\n", pi);         // 3.141593
    printf("Scientific:  %e\n", pi);         // 3.141593e+00
    printf("Shorter:     %g\n", pi);         // 3.14159
    printf("Precision:   %.2f\n", pi);       // 3.14
    printf("Width+Prec:  %10.4f\n", pi);     //     3.1416
    printf("Left-align:  %-10.2f|\n", pi);   // 3.14      |
    printf("Zero-pad:    %08.2f\n", pi);     // 00003.14
    printf("Show sign:   %+.4f\n", pi);      // +3.1416

    printf("Char:        %c\n", ch);         // Z
    printf("String:      %s\n", name);       // Computer Science
    printf("Partial str: %.8s\n", name);     // Computer
    printf("Pointer:     %p\n", (void*)&n); // 0x7ffd...
    printf("Percent:     100%%\n");           // 100%

    return 0;
}

2.7.2 scanf() — Formatted Input

scanf() reads formatted data from stdin. Prototype: int scanf(const char *format, ...);

The & (address-of) operator: scanf() needs the address of a variable to store the value. For basic types, you must use &. For arrays (strings), the name already decays to an address, so & is not used.

C
int age;
float gpa;
char initial;
char name[50];

scanf("%d", &age);       // & required for int
scanf("%f", &gpa);       // & required for float
scanf(" %c", &initial); // & required for char; space skips whitespace
scanf("%49s", name);     // NO & for arrays; 49 = buffer size - 1

Multiple inputs in one scanf():

C
int day, month, year;
printf("Enter date (dd/mm/yyyy): ");
scanf("%d/%d/%d", &day, &month, &year);
// User types: 22/06/2026

Return value of scanf():

scanf() returns the number of items successfully read. This is vital for input validation:

C
int n;
int items_read = scanf("%d", &n);
if (items_read != 1) {
    printf("Invalid input! Expected an integer.\n");
    return 1;
}

2.8 Unformatted I/O Functions

These functions read or write single characters or strings without format specifiers.

C
#include <stdio.h>

int main(void) {
    char ch;

    /* getchar / putchar example */
    printf("Press any key: ");
    ch = getchar();
    printf("You pressed: ");
    putchar(ch);
    putchar('\n');

    /* puts example */
    puts("This line is printed by puts().");

    /* Safe line reading with fgets (replacement for gets) */
    char line[100];
    printf("Enter a line: ");
    getchar();  // consume leftover newline
    fgets(line, sizeof(line), stdin);
    printf("You entered: %s", line);

    return 0;
}

C
#include <stdio.h>

/* Log levels (higher number = more severe) */
#define LOG_DEBUG  0
#define LOG_INFO   1
#define LOG_WARN   2
#define LOG_ERROR  3

/* Current minimum level — change to filter output */
#define MIN_LEVEL  LOG_WARN

void log_message(int level, const char *msg) {
    if (level < MIN_LEVEL)
        return;  // filter out low-priority messages

    const char *prefix;
    switch (level) {
        case LOG_DEBUG: prefix = "[DEBUG]"; break;
        case LOG_INFO:  prefix = "[INFO] "; break;
        case LOG_WARN:  prefix = "[WARN] "; break;
        case LOG_ERROR: prefix = "[ERROR]"; break;
        default:       prefix = "[?????]"; break;
    }
    printf("%s %s\n", prefix, msg);
}

int main(void) {
    log_message(LOG_DEBUG, "Entering main()");
    log_message(LOG_INFO,  "System initialized");
    log_message(LOG_WARN,  "Disk usage at 85%");
    log_message(LOG_ERROR, "Failed to open config file");
    log_message(LOG_INFO,  "User logged in");
    log_message(LOG_ERROR, "Database connection lost");

    return 0;
}

int x = 5;
if (x = 10)
    printf("Yes");
else
    printf("No");

int i = 1;
while (i <= 10) {
    i += 2;
}

for (int i = 0; i < 5; i++) {
    if (i == 3) break;
    printf("%d ", i);
}

int a = 5, b = 2;
printf("%d", a / b);

*        *
**      **
***    ***
****  ****
**********
****  ****
***    ***
**      **
*        *

User-Defined Functions and Storage Classes

3.1 Why Functions?

Functions break a program into smaller, manageable, reusable modules. Benefits:

• Modularity — divide complex problems into sub-problems
• Reusability — write once, call many times
• Abstraction — hide implementation details
• Debugging — easier to isolate and fix bugs
• Team collaboration — different developers can work on different functions

3.2 Function Prototype (Declaration)

A function prototype tells the compiler the function's name, return type, and parameter types before the function is actually defined.

C
// Prototypes (usually at top of file or in header files)
int add(int, int);
float calculateArea(float);
void greet(void);

3.3 Function Definition

C
int add(int a, int b) {   // a, b are formal parameters
    return a + b;
}

float calculateArea(float radius) {
    return 3.14159 * radius * radius;
}

void greet() {
    printf("Hello from greet()!\n");
}

3.4 Function Call

C
#include <stdio.h>

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

int main() {
    int result = add(10, 20);  // 10, 20 are actual parameters
    printf("Sum = %d\n", result);
    return 0;
}

3.5 Categories of Functions

3.6 Call by Value vs Call by Reference

Call by Value (copy of value)

C
#include <stdio.h>

void swapByValue(int a, int b) {
    int temp = a;
    a = b;
    b = temp;
    printf("Inside function: a=%d, b=%d\n", a, b);
}

int main() {
    int x = 10, y = 20;
    swapByValue(x, y);
    printf("In main: x=%d, y=%d\n", x, y);  // NOT swapped!
    return 0;
}

Call by Reference (using pointers)

C
#include <stdio.h>

void swapByRef(int *a, int *b) {
    int temp = *a;
    *a = *b;
    *b = temp;
}

int main() {
    int x = 10, y = 20;
    swapByRef(&x, &y);
    printf("In main: x=%d, y=%d\n", x, y);  // SWAPPED!
    return 0;
}

3.7 Math Library Functions

Include #include <math.h> and compile with -lm flag on Linux.

3.8 Recursive Functions

A function that calls itself is recursive. Every recursive function must have a base case to stop.

Factorial (n!)

C
int factorial(int n) {
    if (n <= 1) return 1;       // Base case
    return n * factorial(n - 1);  // Recursive case
}
// factorial(5) = 5 * 4 * 3 * 2 * 1 = 120

Fibonacci Series

C
int fibonacci(int n) {
    if (n <= 0) return 0;
    if (n == 1) return 1;
    return fibonacci(n-1) + fibonacci(n-2);
}
// 0, 1, 1, 2, 3, 5, 8, 13, 21, 34...

Tower of Hanoi

C
#include <stdio.h>

void hanoi(int n, char from, char to, char aux) {
    if (n == 1) {
        printf("Move disk 1 from %c to %c\n", from, to);
        return;
    }
    hanoi(n-1, from, aux, to);
    printf("Move disk %d from %c to %c\n", n, from, to);
    hanoi(n-1, aux, to, from);
}

int main() {
    hanoi(3, 'A', 'C', 'B');
    return 0;
}

GCD (Euclidean Algorithm)

C
int gcd(int a, int b) {
    if (b == 0) return a;
    return gcd(b, a % b);
}
// gcd(48, 18) = gcd(18, 12) = gcd(12, 6) = gcd(6, 0) = 6

3.9 Scope Rules

C
int globalVar = 100;  // Global scope — accessible everywhere

void demo() {
    int localVar = 50;  // Local scope — only inside demo()
    {
        int blockVar = 25;  // Block scope — only inside this { }
    }
    // blockVar NOT accessible here
}

3.10 Storage Classes

static — Retains Value Across Calls

C
#include <stdio.h>

void counter() {
    static int count = 0;  // Initialized ONCE, retains value
    count++;
    printf("Call #%d\n", count);
}

int main() {
    counter();  // Call #1
    counter();  // Call #2
    counter();  // Call #3
    return 0;
}

C
#include <stdio.h>
#include <math.h>

double power(double base, int exp) { return pow(base, exp); }
double squareRoot(double x) { return sqrt(x); }
long long fact(int n) { if(n<=1) return 1; return n*fact(n-1); }

int main() {
    int choice; double x, y;
    printf("=== Scientific Calculator ===\n");
    printf("1.Power  2.Sqrt  3.Factorial  4.Sin  5.Log\nChoice: ");
    scanf("%d", &choice);
    switch(choice) {
        case 1: printf("Base Exp: "); scanf("%lf %lf",&x,&y);
                printf("Result: %.2f\n", power(x,(int)y)); break;
        case 2: printf("Number: "); scanf("%lf",&x);
                printf("Sqrt: %.4f\n", squareRoot(x)); break;
        case 3: printf("N: "); scanf("%lf",&x);
                printf("%d! = %lld\n", (int)x, fact((int)x)); break;
        case 4: printf("Angle(rad): "); scanf("%lf",&x);
                printf("sin(%.2f) = %.4f\n", x, sin(x)); break;
        case 5: printf("Number: "); scanf("%lf",&x);
                printf("log(%.2f) = %.4f\n", x, log(x)); break;
    }
    return 0;
}

C
#include <stdio.h>

void logMessage(const char *level, const char *msg) {
    static int totalLogs = 0;  // Persists across calls
    totalLogs++;
    printf("[%04d][%s] %s\n", totalLogs, level, msg);
}

int main() {
    logMessage("INFO", "Application started");
    logMessage("DEBUG", "Loading config file");
    logMessage("WARN", "Config key missing, using default");
    logMessage("ERROR", "Database connection failed");
    return 0;
}

Arrays in C

4.1 What is an Array?

An array is a collection of elements of the same data type stored in contiguous memory locations. Instead of declaring 100 separate variables, you declare one array of size 100.

4.2 Declaring and Initializing 1D Arrays

C
int marks[5];                          // Declaration (contains garbage)
int marks[5] = {90, 85, 78, 92, 88};  // Declaration + Init
int marks[] = {90, 85, 78, 92, 88};   // Size inferred (5)
int marks[5] = {90, 85};              // Partial: {90,85,0,0,0}
int marks[5] = {0};                   // All zeros

4.3 Accessing Elements

C
#include <stdio.h>
int main() {
    int arr[5] = {10, 20, 30, 40, 50};
    printf("First: %d\n", arr[0]);   // Index starts at 0
    printf("Last:  %d\n", arr[4]);   // Index = size - 1
    // arr[5] → UNDEFINED BEHAVIOR! C does NOT check bounds.

    // Input and Output using loops
    int n = 5;
    printf("Array: ");
    for (int i = 0; i < n; i++)
        printf("%d ", arr[i]);
    return 0;
}

4.4 Memory Layout

Memory Diagram
arr[0]   arr[1]   arr[2]   arr[3]   arr[4]
┌────────┬────────┬────────┬────────┬────────┐
│   10   │   20   │   30   │   40   │   50   │
└────────┴────────┴────────┴────────┴────────┘
 1000     1004     1008     1012     1016
 (each int = 4 bytes, contiguous)

4.5 2D Arrays

C
int matrix[3][4];  // 3 rows, 4 columns
int matrix[3][3] = {
    {1, 2, 3},
    {4, 5, 6},
    {7, 8, 9}
};

Matrix Addition

C
#include <stdio.h>
int main() {
    int A[2][2] = {{1,2},{3,4}}, B[2][2] = {{5,6},{7,8}}, C[2][2];
    for(int i=0;i<2;i++)
        for(int j=0;j<2;j++)
            C[i][j] = A[i][j] + B[i][j];
    printf("Result:\n");
    for(int i=0;i<2;i++) {
        for(int j=0;j<2;j++) printf("%d ", C[i][j]);
        printf("\n");
    }
    return 0;
}

4.6 Passing Arrays to Functions

C
void printArray(int arr[], int size) {  // arr decays to pointer
    for (int i = 0; i < size; i++)
        printf("%d ", arr[i]);
    printf("\n");
}
// Must pass size separately! sizeof(arr) inside function = pointer size.

4.7 Insertion and Deletion

Insert at Position

C
void insertAt(int arr[], int *n, int pos, int val) {
    for (int i = *n; i > pos; i--)
        arr[i] = arr[i-1];  // Shift right
    arr[pos] = val;
    (*n)++;
}

Delete at Position

C
void deleteAt(int arr[], int *n, int pos) {
    for (int i = pos; i < *n - 1; i++)
        arr[i] = arr[i+1];  // Shift left
    (*n)--;
}

4.8 Linear Search — O(n)

C
int linearSearch(int arr[], int n, int key) {
    for (int i = 0; i < n; i++)
        if (arr[i] == key) return i;
    return -1;  // Not found
}

4.9 Binary Search — O(log n)

Requires a sorted array. Divides search space in half each step.

C
int binarySearch(int arr[], int n, int key) {
    int low = 0, high = n - 1;
    while (low <= high) {
        int mid = (low + high) / 2;
        if (arr[mid] == key) return mid;
        else if (arr[mid] < key) low = mid + 1;
        else high = mid - 1;
    }
    return -1;
}

4.10 Bubble Sort — O(n²)

C
#include <stdio.h>

void bubbleSort(int arr[], int n) {
    for (int i = 0; i < n-1; i++) {
        int swapped = 0;
        for (int j = 0; j < n-i-1; j++) {
            if (arr[j] > arr[j+1]) {
                int temp = arr[j];
                arr[j] = arr[j+1];
                arr[j+1] = temp;
                swapped = 1;
            }
        }
        if (!swapped) break;  // Optimization: already sorted
    }
}

int main() {
    int arr[] = {64, 34, 25, 12, 22, 11, 90};
    int n = 7;
    bubbleSort(arr, n);
    printf("Sorted: ");
    for (int i = 0; i < n; i++) printf("%d ", arr[i]);
    return 0;
}

C
#include <stdio.h>
int main() {
    int n, marks[100], sum = 0, max = 0, topper = 0;
    printf("Number of students: "); scanf("%d", &n);
    for (int i = 0; i < n; i++) {
        printf("Marks of student %d: ", i+1);
        scanf("%d", &marks[i]);
        sum += marks[i];
        if (marks[i] > max) { max = marks[i]; topper = i; }
    }
    printf("Average: %.2f\n", (float)sum / n);
    printf("Topper: Student %d with %d marks\n", topper+1, max);
    return 0;
}

Pointers and Dynamic Memory Allocation

"Understanding pointers is the dividing line between those who can write C and those who truly think in C."
— Adapted from Brian W. Kernighan

5.1 What Are Pointers?

Every variable in a running C program occupies one or more bytes of RAM. Each byte has a unique numeric address. A pointer is simply a variable whose value is the address of another variable.

C
/* Every variable has an address in memory */
int age = 25;           // occupies 4 bytes starting at some address
printf("Value : %d\n", age);     // prints 25
printf("Address: %p\n", (void *)&age);  // prints e.g. 0x7ffd3a9c

ASCII Memory Diagram

   Address       Memory
  ┌──────────┬───────────┐
  │ 0x1000   │   25      │  ← int age
  ├──────────┼───────────┤
  │ 0x1004   │   ...     │
  ├──────────┼───────────┤
  │ 0x1008   │ 0x1000    │  ← int *ptr (holds address of age)
  └──────────┴───────────┘
  

5.2 Pointer Declaration and Initialisation

5.2.1 Declaration Syntax

A pointer is declared by placing an asterisk (*) before the variable name:

C
int    *ip;     // pointer to int
float  *fp;     // pointer to float
char   *cp;     // pointer to char
double *dp;     // pointer to double

5.2.2 The Address-of Operator (&)

The unary & operator yields the memory address of its operand:

C
int x = 42;
int *p = &x;   // p now holds the address of x

5.2.3 The Dereference Operator (*)

The unary * operator (also called the indirection operator) accesses the value stored at the address held by a pointer:

C
printf("%d\n", *p);   // prints 42 — the value at address p
*p = 99;               // changes x to 99 through the pointer
printf("%d\n", x);    // prints 99

Example 5.1 — Basic Pointer Operations

C
/* Example 5.1 — Declaring, initialising, and dereferencing */
#include <stdio.h>

int main(void) {
    int   num   = 10;
    int  *ptr   = &num;

    printf("num   = %d\n",  num);
    printf("&num  = %p\n",  (void *)&num);
    printf("ptr   = %p\n",  (void *)ptr);
    printf("*ptr  = %d\n", *ptr);

    *ptr = 50;   // modify num through ptr
    printf("num after *ptr=50 : %d\n", num);

    return 0;
}

5.3 Size of a Pointer

The size of a pointer depends on the platform, not on the type it points to:

C
/* All pointer types have the same size on a given platform */
printf("sizeof(int*)    = %zu\n", sizeof(int *));
printf("sizeof(char*)   = %zu\n", sizeof(char *));
printf("sizeof(double*) = %zu\n", sizeof(double *));

5.4 Types of Pointers

5.4.1 NULL Pointer

A NULL pointer points to nothing. It is the safest default value for any pointer that does not yet have a valid target.

C
int *p = NULL;    // or int *p = 0;

/* Always check before dereferencing */
if (p != NULL) {
    printf("%d\n", *p);
} else {
    printf("Pointer is NULL — cannot dereference.\n");
}

5.4.2 Dangling Pointer

A dangling pointer points to memory that has been freed or to a local variable that has gone out of scope. Dereferencing it causes undefined behaviour.

C
/* Example: dangling pointer from freed memory */
int *p = (int *)malloc(sizeof(int));
*p = 42;
free(p);       // memory released
// p still holds the old address — it is now DANGLING
// *p = 10;    // UNDEFINED BEHAVIOUR!
p = NULL;      // fix: set to NULL after free

C
/* Example: dangling pointer from out-of-scope variable */
int *bad_function(void) {
    int local = 5;
    return &local;   // WARNING: returning address of local variable!
}

5.4.3 Wild Pointer

A wild pointer is a pointer that has been declared but never initialised. It contains a garbage address and must never be dereferenced.

C
int *wild;       // uninitialised — holds garbage
// *wild = 7;   // CRASH or corruption — never do this!

5.4.4 Void (Generic) Pointer

A void * can hold an address of any type. It is used extensively by malloc() and generic library functions. You must cast it before dereferencing.

C
int a = 10;
void *gp = &a;           // OK: any type → void *
// printf("%d", *gp);    // ERROR: can't dereference void *
printf("%d\n", *(int *)gp);  // OK: cast then dereference → 10

float f = 3.14;
gp = &f;                     // reuse for a different type
printf("%.2f\n", *(float *)gp);  // 3.14

Pointer Types — Quick Reference

5.5 Pointer Expressions and Arithmetic

Pointer arithmetic is one of C's most powerful (and dangerous) features. It lets you move through contiguous memory — like arrays — with simple + and - operations.

5.5.1 Increment and Decrement

When you increment a pointer, it advances by sizeof(pointed-to type) bytes:

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

printf("%d\n", *p);    // 10
p++;                   // moves 4 bytes forward (sizeof(int))
printf("%d\n", *p);    // 20
p++;
printf("%d\n", *p);    // 30

  Memory (assuming int = 4 bytes, arr starts at 0x2000):

  Address:   0x2000   0x2004   0x2008   0x200C
             ┌────┐   ┌────┐   ┌────┐   ┌────┐
  arr[ ]:    │ 10 │   │ 20 │   │ 30 │   │ 40 │
             └────┘   └────┘   └────┘   └────┘
               ↑        ↑        ↑
              p       p+1      p+2
  

5.5.2 Adding and Subtracting an Integer

C
int *q = arr + 3;     // points to arr[3] = 40
printf("%d\n", *q);    // 40

q = q - 2;             // points to arr[1] = 20
printf("%d\n", *q);    // 20

5.5.3 Subtracting Two Pointers

Subtracting two pointers of the same type yields the number of elements between them (not bytes):

C
int *start = &arr[0];
int *end   = &arr[3];
printf("Elements between: %td\n", end - start);  // 3

5.5.4 Forbidden Operations

5.6 Pointer Comparison

You can compare pointers using relational operators. This is most useful when both pointers refer to elements within the same array.

C
int data[] = {5, 10, 15, 20};
int *a = &data[1];
int *b = &data[3];

if (a < b)
    printf("a comes before b in memory\n");   // prints

if (a == b)
    printf("Same location\n");

if (a != NULL)
    printf("a is not NULL\n");               // prints

5.7 Passing Pointers to Functions (Call by Reference)

C is strictly pass-by-value: function parameters are copies. To let a function modify the caller's variable, pass a pointer to that variable.

Example 5.2 — The Classic Swap

C
/* Example 5.2 — Swap two integers using pointers */
#include <stdio.h>

void swap(int *a, int *b) {
    int temp = *a;
    *a = *b;
    *b = temp;
}

int main(void) {
    int x = 3, y = 7;
    printf("Before: x=%d, y=%d\n", x, y);
    swap(&x, &y);
    printf("After : x=%d, y=%d\n", x, y);
    return 0;
}

  How swap works (memory view):

  main's stack:                swap's stack:
  ┌──────┬───┐                ┌──────┬──────────┐
  │  x   │ 3 │ ←──────────── │  *a  │ addr of x│
  ├──────┼───┤                ├──────┼──────────┤
  │  y   │ 7 │ ←──────────── │  *b  │ addr of y│
  └──────┴───┘                └──────┴──────────┘
  

Example 5.3 — Doubling Array Elements via Pointer

C
/* Example 5.3 — Modify array elements through pointers */
#include <stdio.h>

void double_elements(int *arr, int n) {
    for (int i = 0; i < n; i++) {
        *(arr + i) *= 2;    // equivalent to arr[i] *= 2
    }
}

int main(void) {
    int nums[] = {1, 2, 3, 4, 5};
    int n = sizeof(nums) / sizeof(nums[0]);

    double_elements(nums, n);

    for (int i = 0; i < n; i++)
        printf("%d ", nums[i]);
    printf("\n");
    return 0;
}

5.8 Pointers and 1-D Arrays

5.8.1 The Array–Pointer Equivalence

In most contexts, the name of an array decays to a pointer to its first element:

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

/* The famous equivalence */
printf("%d\n", arr[2]);       // 30
printf("%d\n", *(arr + 2));  // 30  — same thing
printf("%d\n", *(p + 2));    // 30  — same thing
printf("%d\n", p[2]);        // 30  — same thing

5.8.2 Differences Between Arrays and Pointers

Example 5.4 — Traversing an Array with a Pointer

C
/* Example 5.4 — Pointer traversal of an array */
#include <stdio.h>

int main(void) {
    int arr[] = {100, 200, 300, 400, 500};
    int n = sizeof(arr) / sizeof(arr[0]);
    int *p = arr;

    printf("Traversing with pointer:\n");
    while (p < arr + n) {
        printf("  Address %p → Value %d\n", (void *)p, *p);
        p++;
    }
    return 0;
}

5.9 Array of Pointers

An array of pointers stores multiple addresses. A common use is an array of strings:

Example 5.5 — Array of String Pointers

C
/* Example 5.5 — Array of pointers to strings */
#include <stdio.h>

int main(void) {
    const char *days[] = {
        "Monday", "Tuesday", "Wednesday",
        "Thursday", "Friday", "Saturday", "Sunday"
    };
    int n = sizeof(days) / sizeof(days[0]);

    for (int i = 0; i < n; i++)
        printf("Day %d: %s\n", i + 1, days[i]);

    return 0;
}

  Memory layout — Array of pointers to strings:

  days[0] ──→ "Monday\0"      (in read-only data segment)
  days[1] ──→ "Tuesday\0"
  days[2] ──→ "Wednesday\0"
  days[3] ──→ "Thursday\0"
  days[4] ──→ "Friday\0"
  days[5] ──→ "Saturday\0"
  days[6] ──→ "Sunday\0"
  

5.10 Pointer to Pointer (Double Pointer)

A double pointer (int **pp) stores the address of another pointer. This adds an extra level of indirection.

Example 5.6 — Double Pointer Demonstration

C
/* Example 5.6 — Double pointer */
#include <stdio.h>

int main(void) {
    int   val  = 100;
    int  *ptr  = &val;
    int **pptr = &ptr;

    printf("val          = %d\n", val);
    printf("*ptr         = %d\n", *ptr);
    printf("**pptr       = %d\n", **pptr);
    printf("Address of val  = %p\n", (void *)&val);
    printf("ptr (addr of val) = %p\n", (void *)ptr);
    printf("pptr(addr of ptr) = %p\n", (void *)pptr);

    return 0;
}

  Double pointer — chain of indirection:

  ┌──────────┐       ┌──────────┐       ┌─────┐
  │  pptr    │ ────→ │  ptr     │ ────→ │ val │
  │ (int **) │       │ (int *)  │       │ 100 │
  │ 0x0028   │       │ 0x0018   │       │0x10 │
  └──────────┘       └──────────┘       └─────┘
    **pptr = 100        *ptr = 100
  

5.11 Function Pointers (Introduction)

Functions in C also reside at memory addresses. A function pointer can store the address of a function and call it indirectly.

Example 5.7 — Function Pointer Basics

C
/* Example 5.7 — Function pointer */
#include <stdio.h>

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

int main(void) {
    // Declare a function pointer
    int (*operation)(int, int);

    operation = add;
    printf("add(3,4) = %d\n", operation(3, 4));

    operation = mul;
    printf("mul(3,4) = %d\n", operation(3, 4));

    return 0;
}

5.12 Dynamic Memory Allocation

5.12.1 Stack vs. Heap

Every running C program has two main areas for variable storage:

  ┌──────────────────────────────────┐  High Address
  │          Stack                   │  ← grows downward
  │  (local vars, return addresses)  │
  ├──────────────────────────────────┤
  │            ↓                     │
  │          (free)                  │
  │            ↑                     │
  ├──────────────────────────────────┤
  │          Heap                    │  ← grows upward
  │  (malloc'd memory)              │
  ├──────────────────────────────────┤
  │   BSS (uninitialised globals)   │
  ├──────────────────────────────────┤
  │   Data (initialised globals)    │
  ├──────────────────────────────────┤
  │   Text (code)                   │
  └──────────────────────────────────┘  Low Address
  

5.12.2 malloc() — Memory Allocation

malloc() allocates a block of uninitialized memory from the heap and returns a void *.

C
/* Syntax: void *malloc(size_t size); */
#include <stdlib.h>

int *p = (int *)malloc(5 * sizeof(int));  // allocate space for 5 ints

if (p == NULL) {
    fprintf(stderr, "Memory allocation failed!\n");
    return 1;
}

// Use the memory
for (int i = 0; i < 5; i++)
    p[i] = (i + 1) * 10;

free(p);       // release when done
p = NULL;      // safety

5.12.3 calloc() — Contiguous Allocation

calloc() allocates memory for an array of elements and zero-initialises every byte.

C
/* Syntax: void *calloc(size_t count, size_t size); */
int *arr = (int *)calloc(5, sizeof(int));   // 5 ints, all set to 0

if (arr == NULL) {
    fprintf(stderr, "calloc failed!\n");
    return 1;
}

for (int i = 0; i < 5; i++)
    printf("%d ", arr[i]);   // prints: 0 0 0 0 0

free(arr);
arr = NULL;

malloc vs calloc

5.12.4 realloc() — Resize Allocated Memory

realloc() changes the size of a previously allocated block. It may move the block to a new location if needed, preserving existing data.

C
/* Syntax: void *realloc(void *ptr, size_t new_size); */
int *arr = (int *)malloc(3 * sizeof(int));
arr[0] = 10; arr[1] = 20; arr[2] = 30;

// Grow to 5 elements
int *temp = (int *)realloc(arr, 5 * sizeof(int));
if (temp == NULL) {
    fprintf(stderr, "realloc failed!\n");
    free(arr);
    return 1;
}
arr = temp;    // update pointer (may have moved)

arr[3] = 40;
arr[4] = 50;

for (int i = 0; i < 5; i++)
    printf("%d ", arr[i]);   // 10 20 30 40 50

free(arr);
arr = NULL;

5.12.5 free() — Releasing Memory

free() returns heap memory to the system. Forgetting to call free() causes a memory leak.

C
/* Syntax: void free(void *ptr); */
int *p = (int *)malloc(sizeof(int));
*p = 42;
free(p);       // release
p = NULL;      // prevent dangling

5.12.6 Double Free and Use-After-Free

Two of the most dangerous bugs in C programs:

C
/* DOUBLE FREE — Undefined Behaviour! */
int *p = (int *)malloc(sizeof(int));
free(p);
free(p);   // ❌ DOUBLE FREE — heap corruption!

/* USE-AFTER-FREE — Undefined Behaviour! */
int *q = (int *)malloc(sizeof(int));
*q = 10;
free(q);
printf("%d\n", *q);  // ❌ USE-AFTER-FREE — reads garbage or crashes

5.13 Dynamic 1-D Arrays

Example 5.8 — Run-Time Sized Array

C
/* Example 5.8 — Dynamic 1D array */
#include <stdio.h>
#include <stdlib.h>

int main(void) {
    int n;
    printf("How many marks? ");
    scanf("%d", &n);

    int *marks = (int *)malloc(n * sizeof(int));
    if (!marks) {
        fprintf(stderr, "Allocation failed\n");
        return 1;
    }

    printf("Enter %d marks:\n", n);
    for (int i = 0; i < n; i++)
        scanf("%d", &marks[i]);

    // Compute average
    int sum = 0;
    for (int i = 0; i < n; i++)
        sum += marks[i];

    printf("Average = %.2f\n", (float)sum / n);

    free(marks);
    marks = NULL;
    return 0;
}

5.14 Dynamic 2-D Arrays (Array of Pointers)

A dynamic 2-D array is built as an array of row pointers, where each row is itself a dynamically allocated 1-D array.

Example 5.9 — Dynamic 2-D Matrix

C
/* Example 5.9 — Dynamic 2D array */
#include <stdio.h>
#include <stdlib.h>

int main(void) {
    int rows = 3, cols = 4;

    /* Step 1: Allocate array of row pointers */
    int **matrix = (int **)malloc(rows * sizeof(int *));
    if (!matrix) { perror("malloc"); return 1; }

    /* Step 2: Allocate each row */
    for (int i = 0; i < rows; i++) {
        matrix[i] = (int *)malloc(cols * sizeof(int));
        if (!matrix[i]) { perror("malloc"); return 1; }
    }

    /* Step 3: Fill with data */
    int count = 1;
    for (int i = 0; i < rows; i++)
        for (int j = 0; j < cols; j++)
            matrix[i][j] = count++;

    /* Step 4: Print */
    printf("Dynamic 2D Matrix:\n");
    for (int i = 0; i < rows; i++) {
        for (int j = 0; j < cols; j++)
            printf("%3d ", matrix[i][j]);
        printf("\n");
    }

    /* Step 5: Free — rows first, then row-pointer array */
    for (int i = 0; i < rows; i++)
        free(matrix[i]);
    free(matrix);
    matrix = NULL;

    return 0;
}

  Memory layout — Dynamic 2D array:

  matrix (int **)
  ┌──────────┐
  │ matrix[0]│ ──→ [  1 |  2 |  3 |  4 ]   (malloc'd row 0)
  ├──────────┤
  │ matrix[1]│ ──→ [  5 |  6 |  7 |  8 ]   (malloc'd row 1)
  ├──────────┤
  │ matrix[2]│ ──→ [  9 | 10 | 11 | 12 ]   (malloc'd row 2)
  └──────────┘

  Freeing order: free each row FIRST, then free matrix itself.
  

5.15 Memory Leak Detection Concepts

A memory leak occurs when dynamically allocated memory is never freed. Over time, leaks cause programs to consume more and more RAM, eventually leading to degraded performance or crashes.

Common Causes

• Forgetting to call free().
• Overwriting a pointer before freeing its old target.
• Early return or error path that skips free().
• Losing the only pointer to allocated memory (reassignment without free).

C
/* Memory leak example */
void leaky(void) {
    int *p = (int *)malloc(100 * sizeof(int));
    // ... use p ...
    // OOPS: function returns without free(p)
    // The 400 bytes are leaked!
}

Detection Tools

5.16 Real-Life Application: Dynamic Student Database

Example 5.10 — Dynamic Student Database

C
/* Example 5.10 — Dynamic student database using realloc */
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

typedef struct {
    int  id;
    char name[50];
    float gpa;
} Student;

/* Add a student — grow the array by 1 */
Student *add_student(Student *db, int *count,
                     int id, const char *name, float gpa) {
    Student *temp = (Student *)realloc(db, (*count + 1) * sizeof(Student));
    if (!temp) {
        fprintf(stderr, "realloc failed\n");
        return db;   // return unchanged
    }
    db = temp;
    db[*count].id = id;
    strncpy(db[*count].name, name, 49);
    db[*count].name[49] = '\0';
    db[*count].gpa = gpa;
    (*count)++;
    return db;
}

/* Remove student by id — shift elements and shrink */
Student *remove_student(Student *db, int *count, int id) {
    int found = -1;
    for (int i = 0; i < *count; i++) {
        if (db[i].id == id) { found = i; break; }
    }
    if (found == -1) {
        printf("Student %d not found.\n", id);
        return db;
    }
    /* Shift remaining elements left */
    for (int i = found; i < *count - 1; i++)
        db[i] = db[i + 1];

    (*count)--;
    if (*count == 0) {
        free(db);
        return NULL;
    }
    Student *temp = (Student *)realloc(db, *count * sizeof(Student));
    return temp ? temp : db;
}

/* Print all students */
void print_students(const Student *db, int count) {
    printf("\n%-5s %-20s %s\n", "ID", "Name", "GPA");
    printf("───── ──────────────────── ─────\n");
    for (int i = 0; i < count; i++)
        printf("%-5d %-20s %.2f\n", db[i].id, db[i].name, db[i].gpa);
}

int main(void) {
    Student *db = NULL;
    int count = 0;

    /* Add students */
    db = add_student(db, &count, 101, "Alice Johnson",  3.85);
    db = add_student(db, &count, 102, "Bob Williams",   3.42);
    db = add_student(db, &count, 103, "Charlie Brown",  3.91);
    db = add_student(db, &count, 104, "Diana Prince",   3.67);

    printf("=== After Adding 4 Students ===");
    print_students(db, count);

    /* Remove student 102 */
    db = remove_student(db, &count, 102);
    printf("\n=== After Removing ID 102 ===");
    print_students(db, count);

    /* Cleanup */
    free(db);
    db = NULL;
    return 0;
}

5.17 Industry Spotlight: Custom Memory Pool Allocator

C
/* Simplified fixed-size memory pool concept */
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#define POOL_SIZE 1024   // 1 KB pool

typedef struct {
    char   data[POOL_SIZE];
    size_t offset;           // next free byte
} MemPool;

void pool_init(MemPool *pool) {
    pool->offset = 0;
    memset(pool->data, 0, POOL_SIZE);
}

void *pool_alloc(MemPool *pool, size_t bytes) {
    if (pool->offset + bytes > POOL_SIZE) {
        fprintf(stderr, "Pool exhausted!\n");
        return NULL;
    }
    void *ptr = pool->data + pool->offset;
    pool->offset += bytes;
    return ptr;
}

void pool_reset(MemPool *pool) {
    pool->offset = 0;   // "free" everything instantly
}

int main(void) {
    MemPool pool;
    pool_init(&pool);

    int *a = (int *)pool_alloc(&pool, sizeof(int));
    int *b = (int *)pool_alloc(&pool, sizeof(int));
    *a = 42;
    *b = 99;

    printf("a=%d, b=%d\n", *a, *b);
    printf("Pool used: %zu / %d bytes\n", pool.offset, POOL_SIZE);

    pool_reset(&pool);
    printf("After reset: %zu bytes used\n", pool.offset);

    return 0;
}

5.18 Practice Exercises

5.19 Multiple Choice Questions

Strings in C

6.1 What is a String in C?

A string in C is a character array terminated by a null character '\0'. There is no built-in string type.

C
char str1[] = "Hello";     // Compiler adds '\0', size = 6
char str2[6] = {'H','e','l','l','o','\0'};  // Manual
char str3[20] = "Hi";      // "Hi\0" + 17 unused bytes

6.2 Reading Strings

C
char name[50];
scanf("%s", name);           // Stops at whitespace! "John Doe" → "John"
fgets(name, 50, stdin);      // Reads full line (SAFE — size limited)
// gets(name);               // DEPRECATED! Buffer overflow risk!

6.3 String Processing — Manual

String Length (without strlen)

C
int myStrlen(char str[]) {
    int len = 0;
    while (str[len] != '\0') len++;
    return len;
}

String Reverse

C
void reverse(char str[]) {
    int len = strlen(str);
    for (int i = 0; i < len/2; i++) {
        char temp = str[i];
        str[i] = str[len-1-i];
        str[len-1-i] = temp;
    }
}

Palindrome Check

C
int isPalindrome(char str[]) {
    int left = 0, right = strlen(str) - 1;
    while (left < right) {
        if (str[left] != str[right]) return 0;
        left++; right--;
    }
    return 1;
}
// isPalindrome("madam") → 1, isPalindrome("hello") → 0

6.4 Character Arithmetic

C
char ch = 'A';          // ASCII 65
printf("%d\n", ch);       // 65
printf("%c\n", ch + 32);  // 'a' (lowercase)
printf("%d\n", '9' - '0');  // 9 (char to int conversion)

6.5 String Library Functions (#include <string.h>)

strtok() — Tokenization

C
#include <stdio.h>
#include <string.h>

int main() {
    char csv[] = "John,25,Engineer,NYC";
    char *token = strtok(csv, ",");
    while (token != NULL) {
        printf("Field: %s\n", token);
        token = strtok(NULL, ",");
    }
    return 0;
}

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

int validatePassword(char pwd[]) {
    int len = strlen(pwd), hasUpper=0, hasLower=0, hasDigit=0, hasSpecial=0;
    if (len < 8) return 0;
    for (int i = 0; i < len; i++) {
        if (isupper(pwd[i])) hasUpper = 1;
        else if (islower(pwd[i])) hasLower = 1;
        else if (isdigit(pwd[i])) hasDigit = 1;
        else hasSpecial = 1;
    }
    return hasUpper && hasLower && hasDigit && hasSpecial;
}

int main() {
    char pwd[] = "Str0ng@Pass";
    printf("%s: %s\n", pwd, validatePassword(pwd) ? "STRONG" : "WEAK");
    return 0;
}

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

typedef struct { char name[50]; int age; float salary; } Employee;

int main() {
    char data[] = "Alice,30,75000.50\nBob,25,62000.00\nCarol,35,95000.75";
    char *line = strtok(data, "\n");
    while (line) {
        Employee e;
        sscanf(line, "%[^,],%d,%f", e.name, &e.age, &e.salary);
        printf("%-10s Age:%-3d Salary:$%.2f\n", e.name, e.age, e.salary);
        line = strtok(NULL, "\n");
    }
    return 0;
}

Structures, Unions, and Macros

Until now, every variable you've created holds a single piece of data — an int, a float, a char. But real-world entities are rarely that simple. A student has a name, a roll number, a GPA, and a date of birth. A network packet has a source address, a destination address, a payload length, and flags. C gives you three powerful tools to handle this complexity: structures to group related data, unions to share memory among alternatives, and macros to teach the preprocessor new tricks before the compiler even sees your code. Together, they bridge the gap between primitive types and the rich data models that real software demands.

7.1 Why Structures? Grouping Related Data

Imagine you're writing a program to manage student records. Without structures, you'd need separate arrays for names, roll numbers, and GPAs:

C
/* Painful approach WITHOUT structures */
char names[100][50];
int  rolls[100];
float gpas[100];

This "parallel arrays" approach is error-prone: if you sort by GPA, you must remember to swap corresponding entries in all three arrays. A single mistake breaks the relationship between a student's name and their roll number. Structures solve this by bundling related data into a single, named unit.

7.2 Declaring a Structure

You declare a structure using the struct keyword followed by a tag name and a list of members enclosed in braces:

C
struct Student {
    char  name[50];
    int   roll;
    float gpa;
};   /* <-- semicolon is mandatory! */

This declaration does not create a variable — it defines a blueprint. Think of it like an architect's floor plan: it describes the layout but doesn't build a house. The tag name Student can then be used to create actual variables (instances) of this type.

7.2.1 Definition and Initialization of Structure Variables

You can define structure variables in several ways:

C
/* Method 1: Separate declaration and definition */
struct Student s1;

/* Method 2: Definition with initialization */
struct Student s2 = {"Alice", 101, 3.85};

/* Method 3: Declaration and definition together */
struct Point {
    int x;
    int y;
} p1 = {10, 20}, p2 = {30, 40};

When you partially initialize a structure, remaining members are set to zero:

C
struct Student s3 = {"Bob"};
/* s3.roll = 0, s3.gpa = 0.0 */

7.2.2 Designated Initializers (C99)

C99 introduced designated initializers, allowing you to initialize members by name in any order:

C — Example 1: Designated Initializers
#include <stdio.h>

struct Student {
    char  name[50];
    int   roll;
    float gpa;
};

int main(void) {
    /* Initialize members by name — order doesn't matter */
    struct Student s = {
        .gpa  = 3.92,
        .name = "Charlie",
        .roll = 205
    };

    printf("Name: %s\n", s.name);
    printf("Roll: %d\n", s.roll);
    printf("GPA : %.2f\n", s.gpa);

    return 0;
}

7.3 Accessing Members: The Dot Operator

The dot operator (.) accesses a member of a structure variable:

C — Example 2: Dot Operator
#include <stdio.h>
#include <string.h>

struct Student {
    char  name[50];
    int   roll;
    float gpa;
};

int main(void) {
    struct Student s1;

    /* Assign values member by member */
    strcpy(s1.name, "Diana");
    s1.roll = 112;
    s1.gpa  = 3.76;

    printf("Student: %s | Roll: %d | GPA: %.2f\n",
           s1.name, s1.roll, s1.gpa);

    return 0;
}

7.3.1 Structure Assignment (Copying All Members)

Unlike arrays, structures can be directly assigned to each other. The compiler copies every member:

C
struct Student s1 = {"Eve", 120, 3.95};
struct Student s2;

s2 = s1;  /* Deep copy of ALL members, including the char array */

printf("%s %d %.2f\n", s2.name, s2.roll, s2.gpa);
/* Output: Eve 120 3.95 */

7.4 Structures and Pointers: The Arrow Operator

When you have a pointer to a structure, you use the arrow operator (->) to access members. It's shorthand for dereferencing and then using the dot operator:

C — Example 3: Arrow Operator
#include <stdio.h>

struct Student {
    char  name[50];
    int   roll;
    float gpa;
};

int main(void) {
    struct Student s = {"Frank", 130, 3.60};
    struct Student *ptr = &s;

    /* These two are equivalent: */
    printf("Using (*ptr).name : %s\n", (*ptr).name);
    printf("Using ptr->name   : %s\n", ptr->name);
    printf("Roll: %d, GPA: %.2f\n", ptr->roll, ptr->gpa);

    return 0;
}

7.5 Nested Structures

A structure can contain another structure as a member, creating a natural hierarchy. This mirrors how real-world data is organized — an employee has an address, and an address itself is composed of multiple fields:

C — Example 4: Nested Structures
#include <stdio.h>

struct Address {
    char street[100];
    char city[50];
    int  zip;
};

struct Employee {
    char   name[50];
    int    id;
    double salary;
    struct Address addr;   /* nested structure */
};

int main(void) {
    struct Employee emp = {
        .name   = "Grace Hopper",
        .id     = 4001,
        .salary = 92000.00,
        .addr   = {
            .street = "42 Innovation Blvd",
            .city   = "Arlington",
            .zip    = 22201
        }
    };

    printf("Employee : %s (ID: %d)\n", emp.name, emp.id);
    printf("Salary   : $%.2f\n", emp.salary);
    printf("Address  : %s, %s %d\n",
           emp.addr.street, emp.addr.city, emp.addr.zip);

    return 0;
}

Notice the chained dot operator: emp.addr.city accesses the city member of the addr member of emp. If you had a pointer to emp, you would write ptr->addr.city.

7.6 Array of Structures

The real power of structures emerges when combined with arrays. An array of structures keeps all data for each entity together, making sorting, searching, and passing data to functions natural:

C — Example 5: Array of Structures with Sorting
#include <stdio.h>
#include <string.h>

struct Student {
    char  name[50];
    int   roll;
    float gpa;
};

/* Sort students by GPA in descending order (selection sort) */
void sort_by_gpa(struct Student arr[], int n) {
    for (int i = 0; i < n - 1; i++) {
        int max_idx = i;
        for (int j = i + 1; j < n; j++) {
            if (arr[j].gpa > arr[max_idx].gpa)
                max_idx = j;
        }
        if (max_idx != i) {
            struct Student temp = arr[i];
            arr[i] = arr[max_idx];
            arr[max_idx] = temp;
        }
    }
}

int main(void) {
    struct Student class[] = {
        {"Alice",   101, 3.85},
        {"Bob",     102, 3.92},
        {"Charlie", 103, 3.45},
        {"Diana",   104, 3.98},
        {"Eve",     105, 3.70}
    };
    int n = sizeof(class) / sizeof(class[0]);

    sort_by_gpa(class, n);

    printf("%-10s %-6s %s\n", "Name", "Roll", "GPA");
    printf("%-10s %-6s %s\n", "----", "----", "---");
    for (int i = 0; i < n; i++) {
        printf("%-10s %-6d %.2f\n",
               class[i].name, class[i].roll, class[i].gpa);
    }

    return 0;
}

Notice how the swap in line 17–19 moves the entire student record at once. No parallel-array nightmare!

7.7 Structures and Functions

Structures interact with functions in three important ways:

7.7.1 Passing a Structure by Value

When you pass a structure by value, the function receives a complete copy. Changes inside the function do not affect the original:

C
void print_student(struct Student s) {
    printf("%s — Roll %d — GPA %.2f\n", s.name, s.roll, s.gpa);
}

7.7.2 Passing a Structure by Pointer (Reference)

C
void give_bonus(struct Employee *emp, double bonus) {
    emp->salary += bonus;   /* modifies original */
}

7.7.3 Returning a Structure from a Function

C — Example 6: Returning Structure
#include <stdio.h>

struct Point {
    double x, y;
};

struct Point midpoint(struct Point a, struct Point b) {
    struct Point mid;
    mid.x = (a.x + b.x) / 2.0;
    mid.y = (a.y + b.y) / 2.0;
    return mid;
}

int main(void) {
    struct Point p1 = {2.0, 4.0};
    struct Point p2 = {8.0, 10.0};
    struct Point m  = midpoint(p1, p2);

    printf("Midpoint: (%.1f, %.1f)\n", m.x, m.y);
    return 0;
}

7.8 typedef with Structures

Typing struct Student everywhere gets tedious. The typedef keyword creates an alias:

C
/* Method 1: typedef after declaration */
struct student_s {
    char  name[50];
    int   roll;
    float gpa;
};
typedef struct student_s Student;

/* Method 2: Combined (anonymous struct + typedef) */
typedef struct {
    double x, y;
} Point;

/* Now use without the 'struct' keyword */
Student s1 = {"Zara", 201, 3.88};
Point   p  = {3.5, 7.2};

7.9 Self-Referential Structures