Introduction to C Programming: How It Works, Why It Matters

/* hello_world.c
   Our very first C program.
   It prints a greeting to the terminal.
   Compile with:  gcc hello_world.c -o hello_world
   Run with:      ./hello_world
*/

#include <stdio.h>   /* Step 1: Include the Standard Input/Output library.
                       This gives us access to printf().
                       Think of it as plugging in a power strip before
                       you can use any of the sockets. */

int main(void)       /* Step 2: Every C program starts here — the main() function.
                       'int' means this function will return an integer when it finishes.
                       'void' means it takes no arguments (inputs). */
{
    /* Step 3: printf() prints formatted text to the terminal.
       '\n' is a newline character — it moves the cursor to the next line,
       just like pressing Enter on a typewriter. */
    printf("Hello from TheCodeForge! C programming starts here.\n");

    /* Step 4: Return 0 to the operating system.
       0 is the universal signal for 'everything went fine'.
       Any other number signals an error. */
    return 0;
}

/* program_anatomy.c
   Demonstrates the key structural parts of a C program.
   We calculate and display a person's birth year from their age.
   Compile: gcc program_anatomy.c -o program_anatomy
   Run:     ./program_anatomy
*/

#include <stdio.h>   /* Preprocessor directive — includes standard I/O functions */

/* ---------- Function Declaration (Prototype) ----------
   This tells the compiler: "a function called calculate_birth_year exists,
   it takes one integer and returns one integer."
   The actual function body comes AFTER main(). */
int calculate_birth_year(int current_age);

/* ---------- main() — Program Entry Point ---------- */
int main(void)
{
    int person_age    = 28;   /* Variable declaration — we reserve space in memory
                                 to store a whole number, and label that space 'person_age' */
    int current_year  = 2024; /* Another integer variable */
    int birth_year;           /* Declared but not yet assigned — holds garbage value until set */

    /* Call our custom function, passing person_age as an argument.
       The result (a birth year) is stored in birth_year. */
    birth_year = calculate_birth_year(person_age);

    /* printf uses format specifiers:
       %d means 'insert an integer here'
       \n moves to the next line */
    printf("Age entered : %d years\n", person_age);
    printf("Current year: %d\n",      current_year);
    printf("Approx. born: %d\n",      birth_year);

    return 0; /* Signal success to the operating system */
}

/* ---------- Function Definition ----------
   Now we write WHAT calculate_birth_year actually does.
   'current_age' here is a local copy — changing it won't affect main(). */
int calculate_birth_year(int current_age)
{
    int estimated_year = 2024 - current_age; /* Simple arithmetic */
    return estimated_year;                   /* Send the result back to the caller */
}

/* variables_and_types.c
   Demonstrates C's fundamental data types with real memory sizes.
   We model a simple product entry — something you'd see in a shop system.
   Compile: gcc variables_and_types.c -o variables_and_types
   Run:     ./variables_and_types
*/

#include <stdio.h>

int main(void)
{
    /* --- Integer type ---
       Use 'int' for whole numbers: counts, IDs, years, ages. */
    int product_id        = 10452;
    int units_in_stock    = 300;

    /* --- Character type ---
       A single character in single quotes.
       'char' internally stores the ASCII numeric code for the character. */
    char product_grade    = 'A';

    /* --- Floating-point types ---
       'float'  is fine for general decimal numbers (prices, percentages).
       'double' gives more decimal precision — prefer it for money in real apps. */
    float  discount_rate  = 0.15f;   /* The 'f' suffix tells the compiler this is a float literal */
    double unit_price     = 49.99;   /* No suffix needed — decimal literals are double by default */

    /* --- Computed values --- */
    double discounted_price = unit_price - (unit_price * discount_rate);
    double total_stock_value = discounted_price * units_in_stock;

    /* --- Printing with matching format specifiers ---
       %d  -> int
       %c  -> char
       %f  -> float or double (both work with printf)
       %.2f -> double, rounded to 2 decimal places */
    printf("=== Product Report ===\n");
    printf("Product ID    : %d\n",   product_id);
    printf("Grade         : %c\n",   product_grade);
    printf("Unit Price    : $%.2f\n", unit_price);
    printf("Discount      : %.0f%%\n", discount_rate * 100); /* %% prints a literal % sign */
    printf("Sale Price    : $%.2f\n", discounted_price);
    printf("Stock         : %d units\n", units_in_stock);
    printf("Total Value   : $%.2f\n", total_stock_value);

    /* sizeof() tells you exactly how many bytes a type uses on your machine */
    printf("\n--- Memory sizes on this machine ---\n");
    printf("int    = %zu bytes\n", sizeof(int));
    printf("char   = %zu bytes\n", sizeof(char));
    printf("float  = %zu bytes\n", sizeof(float));
    printf("double = %zu bytes\n", sizeof(double));

    return 0;
}

/* control_flow.c
   Simulates a simple student grade checker.
   Demonstrates if/else, for loops, and while loops together.
   Compile: gcc control_flow.c -o control_flow
   Run:     ./control_flow
*/

#include <stdio.h>

int main(void)
{
    /* An array holds multiple values of the same type in a row in memory.
       Think of it as a numbered row of lockers.
       Index starts at 0 — the first locker is locker[0], not locker[1]. */
    int exam_scores[5] = {72, 88, 45, 95, 61};
    int number_of_students = 5;
    int total_score = 0;
    int student_index;      /* Loop counter */

    printf("=== Student Grade Report ===\n\n");

    /* --- FOR LOOP ---
       Best when you know exactly how many times to repeat.
       Three parts: initialise ; condition to keep going ; update after each run */
    for (student_index = 0; student_index < number_of_students; student_index++)
    {
        int score = exam_scores[student_index]; /* Grab this student's score */
        char grade_letter;                      /* We'll assign this below */

        /* --- IF / ELSE IF / ELSE ---
           Checks conditions top to bottom and runs the FIRST true block. */
        if (score >= 90)
        {
            grade_letter = 'A';   /* Distinction */
        }
        else if (score >= 75)
        {
            grade_letter = 'B';   /* Merit */
        }
        else if (score >= 55)
        {
            grade_letter = 'C';   /* Pass */
        }
        else
        {
            grade_letter = 'F';   /* Fail — no other condition matched */
        }

        printf("Student %d: Score = %d  ->  Grade %c\n",
               student_index + 1,   /* +1 so we display 1-5, not 0-4 */
               score,
               grade_letter);

        total_score += score;  /* Shorthand for: total_score = total_score + score */
    }

    /* --- WHILE LOOP ---
       Best when you don't know in advance how many repetitions you need.
       Here we use it to count how many students scored above the class average. */
    double class_average = (double)total_score / number_of_students;
    /* The (double) cast is critical — without it, integer division would
       truncate the decimal (e.g. 361/5 = 72, not 72.2) */

    int above_average_count = 0;
    int check_index = 0;

    while (check_index < number_of_students)
    {
        if (exam_scores[check_index] > class_average)
        {
            above_average_count++; /* Shorthand for above_average_count += 1 */
        }
        check_index++; /* ALWAYS update the condition variable — forgetting this causes an infinite loop */
    }

    printf("\nClass average    : %.1f\n", class_average);
    printf("Above average    : %d student(s)\n", above_average_count);

    return 0;
}