C Programming Essentials

Welcome to the world of C programming! This page covers fundamental concepts and crucial next steps, complete with code examples and explanations.

1. Basic Structure of a C Program

Every C program begins with a fundamental structure.

#include <stdio.h> // Header file for standard input/output functions

int main() { // Main function: the entry point of every C program
    // Your code goes here
    printf("Hello, World!\n"); // Prints "Hello, World!" to the console
    return 0; // Indicates successful execution of the program
}

Explanation:

`#include <stdio.h>`: This line is a preprocessor directive that includes the standard input/output library, providing functions like `printf`.
`int main()`: This is the main function, the starting point of every C program. `int` signifies that it will return an integer value.
`{ ... }`: The curly braces define the scope of the function.
`printf("Hello, World!\n");`: Uses the `printf` function to print a string to the console. `\n` is a newline character.
`return 0;`: Exits the `main` function and indicates successful execution to the operating system.

2. Variables and Data Types

Variables store data. In C, you must declare a variable's data type before using it.

#include <stdio.h>

int main() {
    // Integer type
    int age = 30;
    printf("Age: %d\n", age);

    // Floating-point types
    float price = 19.99;
    double pi = 3.1415926535;
    printf("Price: %.2f\n", price); // .2f limits to two decimal places
    printf("Pi: %lf\n", pi);

    // Character type
    char grade = 'A';
    printf("Grade: %c\n", grade);

    // Boolean (using int, as C doesn't have a built-in bool type before C99)
    // For C99 and later, you can include <stdbool.h>
    int isRaining = 1; // 1 for true, 0 for false
    printf("Is it raining? %d (1=Yes, 0=No)\n", isRaining);

    return 0;
}

Explanation:

`int age = 30;`: Declares an integer variable `age` and initializes it to `30`. `%d` is the format specifier for integers in `printf`.
`float price = 19.99;` and `double pi = 3.1415926535;`: Declare floating-point variables. `float` provides single precision, `double` provides double precision. `%f` (for float) and `%lf` (for double) are their respective format specifiers.
`char grade = 'A';`: Declares a character variable `grade`. Characters are enclosed in single quotes. `%c` is the format specifier.
`int isRaining = 1;`: Before C99, booleans were typically represented by `int` (0 for false, non-zero for true).

3. Operators

Operators perform operations on variables and values.

#include <stdio.h>

int main() {
    int a = 10, b = 5;
    int result;

    // Arithmetic Operators
    result = a + b; // Addition
    printf("a + b = %d\n", result);
    result = a - b; // Subtraction
    printf("a - b = %d\n", result);
    result = a * b; // Multiplication
    printf("a * b = %d\n", result);
    result = a / b; // Division (integer division)
    printf("a / b = %d\n", result);
    result = a % b; // Modulo (remainder)
    printf("a %% b = %d\n", result); // %% to print a literal %

    // Relational Operators (return 0 or 1)
    printf("a > b: %d\n", a > b);   // Greater than
    printf("a < b: %d\n", a < b);   // Less than
    printf("a == b: %d\n", a == b); // Equality check
    printf("a != b: %d\n", a != b); // Inequality check

    // Logical Operators (return 0 or 1)
    int x = 5, y = 10;
    printf("(x > 0 && y < 20): %d\n", (x > 0 && y < 20)); // AND
    printf("(x < 0 || y < 5): %d\n", (x < 0 || y < 5));   // OR
    printf("!(x == 5): %d\n", !(x == 5));                 // NOT

    // Assignment Operators
    int c = 10;
    c += 5; // c = c + 5;
    printf("c after c += 5: %d\n", c);

    // Increment/Decrement Operators
    int i = 0;
    i++; // i = i + 1; (post-increment)
    printf("i after i++: %d\n", i);
    ++i; // i = i + 1; (pre-increment)
    printf("i after ++i: %d\n", i);

    return 0;
}

Explanation:

Arithmetic: `+`, `-`, `*`, `/`, `%` (modulo). Note that `/` performs integer division if both operands are integers.
Relational: `==` (equal to), `!=` (not equal to), `>` (greater than), `<` (less than), `>=` (greater than or equal to), `<=` (less than or equal to). They return `1` for true, `0` for false.
Logical: `&&` (AND), `||` (OR), `!` (NOT). Used to combine or negate conditions.
Assignment: `+=`, `-=`, `*=`, `/=`, `%=` are shorthand for `c = c + 5`, etc.
Increment/Decrement: `++` and `--` increase or decrease a variable by 1. `i++` (post-increment) uses the value then increments; `++i` (pre-increment) increments then uses the value.

4. Input/Output (I/O)

Interact with the user using input and output functions from the <stdio.h> library.

#include <stdio.h>

int main() {
    int num;
    char name[50]; // Character array to store a string

    // Taking integer input
    printf("Enter an integer: ");
    scanf("%d", &num); // &num is the address of the variable num
    printf("You entered: %d\n", num);

    printf("Enter your full name (with spaces): ");
    // Clear the input buffer before using fgets after scanf
    // This consumes the leftover newline character from the previous scanf
    while (getchar() != '\n'); 

    fgets(name, sizeof(name), stdin); // Reads up to sizeof(name)-1 chars or until newline
    printf("Welcome, %s", name); // name contains the newline character from fgets

    return 0;
}

Explanation:

`printf()`: Used to display output to the console.
`scanf()`: Used to read formatted input. Note the `&` (address-of operator) before `num` when reading an integer.
`fgets()`: A safer alternative for reading strings, especially when they might contain spaces, as it reads an entire line until a newline character or a specified buffer size is reached. It includes the newline character if read.
`while (getchar() != '\n');`: This is a common way to "clear the input buffer" after using `scanf` and before using `fgets` to consume any leftover newline characters that `scanf` might leave behind.

5. Control Flow Statements

Control flow statements determine the order in which instructions are executed.

a) `if-else if-else` (Conditional Statements)

#include <stdio.h>

int main() {
    int score = 75;

    if (score >= 90) {
        printf("Grade: A\n");
    } else if (score >= 80) {
        printf("Grade: B\n");
    } else if (score >= 70) {
        printf("Grade: C\n");
    } else {
        printf("Grade: F\n");
    }

    return 0;
}

Explanation:

The `if` statement executes a block of code if its condition is true.
`else if` provides alternative conditions to check if the preceding `if` or `else if` conditions were false.
`else` executes its block if none of the preceding `if` or `else if` conditions are true.

b) `switch` Statement

#include <stdio.h>

int main() {
    char grade = 'B';

    switch (grade) {
        case 'A':
            printf("Excellent!\n");
            break; // Exit the switch statement
        case 'B':
            printf("Good!\n");
            break;
        case 'C':
            printf("Fair.\n");
            break;
        case 'D':
            printf("Needs improvement.\n");
            break;
        case 'F':
            printf("Fail.\n");
            break;
        default: // If no case matches
            printf("Invalid grade.\n");
    }

    return 0;
}

Explanation:

The `switch` statement allows a variable to be tested for equality against a list of values (`case` labels).
`break;` is essential to exit the `switch` block once a match is found; otherwise, execution "falls through" to the next `case`.
`default:` is optional and executes if no `case` matches the switch expression's value.

c) Loops (`for`, `while`, `do-while`)

#include <stdio.h>

int main() {
    printf("For loop:\n");
    // Initialization; Condition; Iteration
    for (int i = 1; i <= 3; i++) {
        printf("%d ", i);
    }
    printf("\n");

    printf("While loop:\n");
    int j = 1; // Initialization
    while (j <= 3) { // Condition
        printf("%d ", j);
        j++; // Iteration
    }
    printf("\n");

    printf("Do-While loop:\n");
    int k = 1; // Initialization
    do {
        printf("%d ", k);
        k++; // Iteration
    } while (k <= 3); // Condition checked after first iteration
    printf("\n");

    return 0;
}

Explanation:

`for` loop: Ideal when the number of iterations is known. It combines initialization, condition, and iteration in one line.
`while` loop: Continues to execute as long as its condition is true. The condition is checked before each iteration.
`do-while` loop: Similar to `while`, but guarantees that the loop body executes at least once before the condition is checked.

6. Arrays

Arrays are collections of elements of the same data type, stored in contiguous memory locations.

#include <stdio.h>
#include <string.h> // For string functions like strcpy

int main() {
    // Declaring and initializing an integer array
    int numbers[5] = {10, 20, 30, 40, 50};

    // Accessing array elements (indexing starts from 0)
    printf("First element: %d\n", numbers[0]); // Output: 10
    printf("Third element: %d\n", numbers[2]); // Output: 30

    // Modifying an element
    numbers[1] = 25;
    printf("Modified second element: %d\n", numbers[1]);

    // Iterating through an array
    printf("All elements: ");
    for (int i = 0; i < 5; i++) {
        printf("%d ", numbers[i]);
    }
    printf("\n");

    // Character array (string) - null-terminated
    char greeting[] = "Hello"; // Size is automatically determined (6 characters including null)
    printf("Greeting: %s\n", greeting);

    // Accessing characters in a string
    printf("First character of greeting: %c\n", greeting[0]);

    return 0;
}

Explanation:

`int numbers[5] = {10, 20, 30, 40, 50};`: Declares an array named `numbers` that can hold 5 integers, initialized with the given values.
Elements are accessed using zero-based indexing (e.g., `numbers[0]` is the first element).
`char greeting[] = "Hello";`: A character array is used to store strings. C strings are always terminated by a null character (`\0`). The size is automatically determined to be 6 (`'H', 'e', 'l', 'l', 'o', '\0'`).

7. Functions

Functions are blocks of code that perform a specific task. They promote code reusability and modularity.

#include <stdio.h>

// Function declaration (prototype) - tells compiler about the function
int add(int a, int b);
void greet(char name[]);

int main() {
    int sum = add(5, 7); // Call the add function
    printf("Sum: %d\n", sum);

    greet("Alice"); // Call the greet function
    greet("Bob");

    return 0;
}

// Function definition - contains the actual code
int add(int a, int b) {
    return a + b; // Returns the sum of a and b
}

void greet(char name[]) {
    printf("Hello, %s!\n", name); // Does not return a value (void)
}

Explanation:

Function Declaration (Prototype): Placed before `main`, it informs the compiler about the function's name, return type (`int` for `add`, `void` for `greet`), and parameters (types and order).
Function Definition: Contains the actual logic of the function.
Function Call: Invokes the function using its name and passing required arguments (e.g., `add(5, 7)`).
`return` statement: Used in non-`void` functions to send a value back to the caller.

8. Pointers

Pointers are variables that store memory addresses of other variables. They are fundamental for dynamic memory, arrays, and data structures.

#include <stdio.h>

int main() {
    int num = 10;
    int *ptr; // Declare a pointer to an integer (ptr will store an address of an int)

    ptr = &num; // Store the memory address of 'num' in 'ptr' (& is "address-of")

    printf("Value of num: %d\n", num);
    printf("Address of num: %p\n", &num); // %p is for printing addresses
    printf("Value of ptr (address stored): %p\n", ptr);
    printf("Value at the address pointed by ptr: %d\n", *ptr); // * is "dereference" (access value at address)

    // Changing value through pointer
    *ptr = 20; // Modify the value at the address pointed to by ptr
    printf("New value of num (changed via pointer): %d\n", num);

    return 0;
}

Explanation:

`int *ptr;`: Declares `ptr` as a pointer variable that can hold the memory address of an `int`.
`ptr = &num;`: The address-of operator (`&`) gets the memory address of `num` and assigns it to `ptr`.
`printf("... %p\n", ptr);`: `%p` is the format specifier for printing pointer addresses.
`*ptr`: The dereference operator (`*`) accesses the value stored at the memory address currently held by `ptr`. Changing `*ptr` directly modifies `num`.

9. Structures (Structs)

Structures allow you to group variables of different data types under a single name, creating custom data types.

#include <stdio.h>
#include <string.h> // For strcpy

// Define a structure named Student
struct Student {
    char name[50]; // Member 1: character array for name
    int roll_number; // Member 2: integer for roll number
    float marks; // Member 3: float for marks
};

int main() {
    // Declare a structure variable
    struct Student student1;

    // Access and assign values to members using the dot operator (.)
    strcpy(student1.name, "John Doe"); // Use strcpy for string assignment
    student1.roll_number = 101;
    student1.marks = 85.5;

    // Print structure members
    printf("Student Name: %s\n", student1.name);
    printf("Roll Number: %d\n", student1.roll_number);
    printf("Marks: %.2f\n", student1.marks);

    // Another way to initialize a structure variable
    struct Student student2 = {"Jane Smith", 102, 92.0};
    printf("\nStudent Name: %s\n", student2.name);
    printf("Roll Number: %d\n", student2.roll_number);
    printf("Marks: %.2f\n", student2.marks);

    return 0;
}

Explanation:

`struct Student { ... };`: Defines a new data type called `Student` which is a blueprint for student records.
`struct Student student1;`: Declares a variable `student1` of type `struct Student`.
`student1.name`, `student1.roll_number`, `student1.marks`: Members of the structure are accessed using the dot operator (`.`).
`strcpy()`: Used to copy strings into character arrays within the struct, as direct assignment (`=`) doesn't work for arrays.
You can also initialize a struct variable directly upon declaration using curly braces `{}`.

Next Steps in C Programming Essentials

1. File Input/Output (I/O)

Learn how to interact with files on your computer's disk, allowing your program to persist data and read external information.

#include <stdio.h>
#include <stdlib.h> // For exit() (optional, but good for error handling)

int main() {
    FILE *filePointer; // Declare a file pointer
    char data[100];

    // --- Writing to a file ---
    // "w" mode: open for writing (creates file if it doesn't exist, overwrites if it does)
    filePointer = fopen("example.txt", "w");
    if (filePointer == NULL) {
        printf("Error opening file for writing!\n");
        return 1; // Indicate an error
    }
    fprintf(filePointer, "Hello, C File I/O!\n"); // Write formatted output to the file
    fprintf(filePointer, "This is a new line.\n");
    fclose(filePointer); // Close the file
    printf("Data written to example.txt\n");

    // --- Reading from a file ---
    // "r" mode: open for reading
    filePointer = fopen("example.txt", "r");
    if (filePointer == NULL) {
        printf("Error opening file for reading!\n");
        return 1;
    }
    printf("\nReading from example.txt:\n");
    // Read line by line until end of file (NULL)
    while (fgets(data, sizeof(data), filePointer) != NULL) {
        printf("%s", data); // fgets includes the newline character
    }
    fclose(filePointer); // Close the file

    return 0;
}

Explanation:

`FILE *filePointer;`: Declares a pointer to a `FILE` object, which is used to manage the file stream.
`fopen("filename.txt", "mode")`: Opens a file. Common modes: `"r"` (read), `"w"` (write, overwrites), `"a"` (append), `"rb"` (read binary), `"wb"` (write binary). Returns `NULL` on failure.
`fprintf(filePointer, ...)`: Similar to `printf`, but writes to the specified `filePointer`.
`fgets(buffer, size, filePointer)`: Reads a line from the file into `buffer` up to `size-1` characters or until a newline.
`fclose(filePointer)`: Crucial to close the file after operations to release resources and ensure data is written.

2. Dynamic Memory Allocation

Allocate memory at runtime (while the program is running) using functions from <stdlib.h>. This is essential when you don't know the exact size of data needed at compile time.

#include <stdio.h>
#include <stdlib.h> // For malloc, free

int main() {
    int *arr; // Pointer to an integer array (will be dynamically allocated)
    int n;
    int i;

    printf("Enter the number of elements: ");
    scanf("%d", &n);

    // Allocate memory for n integers using malloc
    // malloc returns void*, so cast it to (int*)
    // sizeof(int) determines the bytes needed for one integer
    arr = (int *) malloc(n * sizeof(int));

    // Check if malloc was successful (returns NULL on failure)
    if (arr == NULL) {
        printf("Memory allocation failed!\n");
        return 1; // Indicate an error
    }

    printf("Enter %d integers:\n", n);
    for (i = 0; i < n; i++) {
        scanf("%d", &arr[i]); // Populate the dynamically allocated array
    }

    printf("You entered: ");
    for (i = 0; i < n; i++) {
        printf("%d ", arr[i]); // Print elements
    }
    printf("\n");

    // Deallocate the memory when no longer needed
    free(arr);
    arr = NULL; // Good practice: set pointer to NULL after freeing to prevent dangling pointer issues

    printf("Memory freed.\n");

    return 0;
}

Explanation:

`malloc(size_in_bytes)`: Allocates a block of memory of the specified size (in bytes) and returns a `void*` pointer to the beginning of the block. The allocated memory contains garbage values.
`calloc(num_elements, element_size)`: Similar to `malloc`, but initializes all allocated bytes to zero. Useful for arrays.
`realloc(ptr, new_size)`: Resizes a previously allocated memory block.
`free(ptr)`: Crucial to deallocate memory that was dynamically allocated. Failing to `free` memory leads to memory leaks.
`arr = NULL;`: After freeing, it's good practice to set the pointer to `NULL` to prevent it from being a "dangling pointer" (pointing to deallocated memory).

3. Strings (Advanced)

While `char` arrays cover basic strings, the <string.h> library provides powerful functions for string manipulation. Remember, C strings are null-terminated character arrays.

#include <stdio.h>
#include <string.h> // For string functions

int main() {
    char str1[50] = "Hello";
    char str2[50] = " World";
    char str3[50];
    char str4[50] = "Hello";

    // strlen(): Returns the length of a string (excluding the null terminator)
    printf("Length of str1: %zu\n", strlen(str1)); // %zu is for size_t type

    // strcpy(destination, source): Copies one string to another. Beware of buffer overflows!
    strcpy(str3, str1);
    printf("str3 after strcpy(str3, str1): %s\n", str3);

    // strcat(destination, source): Concatenates (joins) two strings. Beware of buffer overflows!
    strcat(str1, str2); // str1 is now "Hello World"
    printf("str1 after strcat(str1, str2): %s\n", str1);

    // strcmp(string1, string2): Compares two strings lexicographically
    // Returns 0 if equal, < 0 if string1 is smaller, > 0 if string1 is larger
    if (strcmp(str1, str4) == 0) {
        printf("str1 and str4 are equal.\n");
    } else {
        printf("str1 and str4 are not equal.\n"); // This will be printed ("Hello World" vs "Hello")
    }

    if (strcmp(str3, str4) == 0) {
        printf("str3 and str4 are equal.\n"); // This will be printed ("Hello" vs "Hello")
    }

    // strstr(haystack, needle): Finds the first occurrence of a substring
    char *sub = strstr(str1, "World");
    if (sub != NULL) {
        printf("Found 'World' in str1 starting at: %s\n", sub);
    } else {
        printf("'World' not found in str1.\n");
    }

    return 0;
}

Explanation:

`strlen(str)`: Calculates the length of the string, excluding the null terminator.
`strcpy(dest, src)`: Copies the content of `src` string to `dest`. Caution: Ensure `dest` has enough space to prevent buffer overflows. `strncpy` is a safer alternative.
`strcat(dest, src)`: Appends the `src` string to the `dest` string. Caution: Also prone to buffer overflows. `strncat` is safer.
`strcmp(str1, str2)`: Compares two strings character by character. It returns `0` if they are identical.
`strstr(haystack, needle)`: Searches for the first occurrence of `needle` within `haystack` and returns a pointer to the beginning of the found substring, or `NULL` if not found.

4. Enumerations (Enums)

Enums (enumerations) allow you to define a set of named integer constants. They improve code readability and make it easier to work with a fixed set of related values.

#include <stdio.h>

// Define an enum for days of the week
// By default, SUNDAY = 0, MONDAY = 1, etc.
enum Day {
    SUNDAY,
    MONDAY,
    TUESDAY,
    WEDNESDAY,
    THURSDAY,
    FRIDAY,
    SATURDAY
};

// Define an enum for months, explicitly assigning values
// JAN = 1, then FEB automatically becomes 2, MAR = 3, etc.
enum Month {
    JAN = 1,
    FEB,
    MAR,
    APR,
    MAY,
    JUN,
    JUL,
    AUG,
    SEP,
    OCT,
    NOV,
    DEC
};

int main() {
    enum Day today = WEDNESDAY;
    enum Month currentMonth = JUN;

    printf("Today is day number: %d\n", today); // Output: 3 (WEDNESDAY is the 4th element, 0-indexed)
    printf("Current month number: %d\n", currentMonth); // Output: 6

    if (today == WEDNESDAY) {
        printf("It's hump day!\n");
    }

    switch (currentMonth) {
        case JAN:
        case FEB:
        case DEC:
            printf("It's winter (in the Northern Hemisphere).\n");
            break;
        case JUN:
        case JUL:
        case AUG:
            printf("It's summer (in the Northern Hemisphere).\n");
            break;
        default:
            printf("It's another season.\n");
    }

    return 0;
}

Explanation:

`enum Day { ... };`: Defines an enumeration `Day`. By default, the first enumerator (`SUNDAY`) is `0`, the next (`MONDAY`) is `1`, and so on.
`enum Month { JAN = 1, ... };`: You can explicitly assign integer values. If you assign a value to an enumerator, subsequent enumerators without explicit assignments will increment from that value.
Enums make code more readable by using meaningful names instead of raw numbers.

5. Unions

A union is a special data type that allows you to store different data types in the same memory location. It can only hold one member's value at a time. The size of a union is determined by the size of its largest member.

#include <stdio.h>
#include <string.h> // For strcpy

union Data {
    int i;
    float f;
    char str[20];
};

int main() {
    union Data data; // Declare a union variable

    data.i = 10;
    printf("data.i (after int assignment): %d\n", data.i);
    // After assigning to 'i', 'f' and 'str' contain garbage/undefined values
    printf("data.f (garbage after int assignment): %f\n", data.f);

    data.f = 220.5; // Assign to float member - this overwrites the memory shared by 'i' and 'str'
    printf("data.f (after float assignment): %f\n", data.f);
    printf("data.i (garbage after float assignment): %d\n", data.i); // 'i' is now corrupted

    // Assign to string member - this overwrites the memory shared by 'i' and 'f'
    strcpy(data.str, "C Programming");
    printf("data.str (after string assignment): %s\n", data.str);

    // Only the last assigned member is valid! Accessing others will lead to undefined behavior.
    printf("data.i (garbage after string assignment): %d\n", data.i);
    printf("data.f (garbage after string assignment): %f\n", data.f);

    return 0;
}

Explanation:

`union Data { ... };`: Defines a union named `Data`. All members of a union share the same memory space.
The size of a union is equal to the size of its largest member (`char str[20]` in this case).
Crucial Point: Only one member of a union can hold a valid value at any given time. When you assign a value to one member, the values of other members become undefined (garbage). Unions are often used in memory-constrained environments or when you need to represent the same data in different formats.

6. Command Line Arguments

Command line arguments allow you to pass information to your C program when you run it from the terminal or command prompt. This enables flexible and dynamic program execution.

#include <stdio.h>
#include <stdlib.h> // For atoi() - ASCII to Integer conversion

// The main function can optionally take two parameters for command line arguments
// argc: Argument Count (number of arguments, including the program name itself)
// argv: Argument Vector (an array of strings, where each string is an argument)
int main(int argc, char *argv[]) {
    printf("Number of arguments: %d\n", argc);

    printf("Arguments received:\n");
    // argv[0] is always the program's name
    // argv[1] is the first argument, argv[2] the second, and so on.
    for (int i = 0; i < argc; i++) {
        printf("argv[%d]: %s\n", i, argv[i]);
    }

    // Example: Taking two numbers from command line and adding them
    if (argc == 3) { // Expecting program_name, num1, num2 (total 3 arguments)
        // Convert string arguments to integers using atoi()
        int num1 = atoi(argv[1]);
        int num2 = atoi(argv[2]);
        int sum = num1 + num2;
        printf("\nSum of %d and %d is: %d\n", num1, num2, sum);
    } else if (argc > 1) {
        printf("\nUsage: %s <number1> <number2> (for sum example)\n", argv[0]);
    } else {
        printf("\nNo additional arguments provided.\n");
    }

    return 0;
}

Explanation:

`int main(int argc, char *argv[])`: This special signature for `main` allows it to receive command line arguments.
`argc` (argument count): An integer that holds the total number of arguments passed to the program, including the program's name itself.
`argv` (argument vector): An array of character pointers (strings). `argv[0]` is always the name of the executable, `argv[1]` is the first argument provided, `argv[2]` the second, and so on.
`atoi()`: A function from `<stdlib.h>` that converts a string (ASCII) to an integer. You often need to convert string arguments to numerical types if you intend to perform calculations.

How to run (after compiling, e.g., `gcc myprogram.c -o myprogram`):

./myprogram                       # Output will show "No additional arguments"
./myprogram hello world           # Output will list "hello" and "world" as arguments
./myprogram 10 20                 # Output: "Sum of 10 and 20 is: 30"

7. Preprocessor Directives

Preprocessor directives are instructions to the C preprocessor, which processes your code before compilation. They are not C statements themselves, but rather commands that modify the source code before it reaches the compiler.

#include <stdio.h>

// 1. Symbolic Constant: #define replaces text literally before compilation
#define PI 3.14159
#define GREETING "Hello from the Preprocessor!"

// 2. Simple Function-like Macro: also performs text replacement, supports arguments
// Wrap arguments and the entire macro in parentheses to prevent side effects
#define MAX(a, b) ((a) > (b) ? (a) : (b))
#define MULTIPLY(x, y) (x * y)

// 3. Conditional Compilation: #ifdef, #ifndef, #if, #else, #elif, #endif
// Code blocks are included or excluded based on whether a macro is defined
#define DEBUG_MODE // Uncomment this line to enable debug messages

int main() {
    printf("Value of PI: %f\n", PI);
    printf("%s\n", GREETING);

    int val1 = 10, val2 = 20;
    printf("Max of %d and %d is: %d\n", val1, val2, MAX(val1, val2));
    printf("Product of 5 and 4 is: %d\n", MULTIPLY(5, 4));

    // This block only gets compiled if DEBUG_MODE is defined
    #ifdef DEBUG_MODE
        printf("[DEBUG] Debug mode is active. Variable val1 = %d, val2 = %d\n", val1, val2);
    #else
        printf("[INFO] Debug mode is inactive.\n");
    #endif

    // Example of #if for standard version check
    #if __STDC_VERSION__ >= 199901L
        printf("Compiling with C99 or later standard.\n");
    #else
        printf("Compiling with an older C standard.\n");
    #endif

    return 0;
}

Explanation:

`#define PI 3.14159`: Defines a symbolic constant. Everywhere `PI` appears in the code, the preprocessor will replace it with `3.14159` before compilation.
`#define MAX(a, b) ((a) > (b) ? (a) : (b))`: Defines a function-like macro. It's a text substitution, not a function call, and operates during preprocessing. Parentheses are crucial to prevent operator precedence issues.
`#ifdef DEBUG_MODE ... #endif`: Conditional compilation. The code between `#ifdef` and `#endif` (or `#else`/`#elif`) will only be included in the compilation if `DEBUG_MODE` is defined. This is useful for turning on/off debug features or platform-specific code.
`#if __STDC_VERSION__ >= 199901L`: Checks the C standard version being used. `__STDC_VERSION__` is a predefined macro.
Other directives: `#undef` (undefines a macro), `#error` (generates a compilation error), `#warning` (generates a compilation warning).

This HTML page now provides a solid foundation for your C programming journey, with clearer explanations and properly formatted code blocks. Keep practicing and exploring!