Understanding C: The Foundation of Modern Computing

C is a powerful, efficient programming language developed by Dennis Ritchie at Bell Labs in 1972. It serves as the foundation for modern operating systems, embedded systems, and high-performance applications. C provides low-level memory access while maintaining portability across different platforms.

What makes C unique is its close-to-hardware nature combined with high-level language features. It's used in operating systems (Linux, Windows), embedded systems, compilers, databases, and performance-critical applications where efficiency is paramount.

1. C Basics & Syntax

// hello.c
#include <stdio.h>  // Standard Input Output header

int main() {
    printf("Hello, World!\n");
    printf("Welcome to C Programming!\n");
    return 0;  // Indicates successful execution
}

// Compile and run:
// gcc hello.c -o hello
// ./hello

#include <stdio.h>

int main() {
    // Basic data types
    char grade = 'A';           // Single character (1 byte)
    int age = 25;               // Integer (4 bytes typically)
    short smallNumber = 100;    // Short integer (2 bytes)
    long bigNumber = 123456L;   // Long integer (8 bytes typically)
    
    float price = 19.99f;       // Single precision floating point (4 bytes)
    double salary = 75000.50;   // Double precision floating point (8 bytes)
    
    // Unsigned types (only positive values)
    unsigned int positiveOnly = 200;
    
    // Constants
    const float PI = 3.14159f;
    
    // Printing variables with format specifiers
    printf("Grade: %c\n", grade);
    printf("Age: %d\n", age);
    printf("Price: %.2f\n", price);
    printf("Salary: %.2f\n", salary);
    printf("PI: %.5f\n", PI);
    
    // Size of data types
    printf("Size of char: %lu bytes\n", sizeof(char));
    printf("Size of int: %lu bytes\n", sizeof(int));
    printf("Size of float: %lu bytes\n", sizeof(float));
    printf("Size of double: %lu bytes\n", sizeof(double));
    
    return 0;
}

#include <stdio.h>

int main() {
    // Variable declarations
    char name[50];
    int age;
    float height;
    
    // Getting input from user
    printf("Enter your name: ");
    scanf("%49s", name);  // Read string (max 49 characters)
    
    printf("Enter your age: ");
    scanf("%d", &age);    // Read integer (note the & operator)
    
    printf("Enter your height (in meters): ");
    scanf("%f", &height); // Read float
    
    // Displaying the collected information
    printf("\n--- User Information ---\n");
    printf("Name: %s\n", name);
    printf("Age: %d years\n", age);
    printf("Height: %.2f meters\n", height);
    
    // Character input/output
    char initial;
    printf("Enter your first initial: ");
    getchar();  // Consume the newline character from previous input
    initial = getchar();
    printf("Your initial is: %c\n", initial);
    
    // Formatted output with field width
    printf("\n--- Formatted Output ---\n");
    printf("Name: %-20s | Age: %3d | Height: %6.2f\n", name, age, height);
    
    return 0;
}

#include <stdio.h>

int main() {
    int a = 15, b = 4;
    
    // Arithmetic operators
    printf("a = %d, b = %d\n", a, b);
    printf("a + b = %d\n", a + b);    // Addition: 19
    printf("a - b = %d\n", a - b);    // Subtraction: 11
    printf("a * b = %d\n", a * b);    // Multiplication: 60
    printf("a / b = %d\n", a / b);    // Division: 3 (integer division)
    printf("a %% b = %d\n", a % b);   // Modulus: 3
    
    // Floating point division
    float result = (float)a / b;
    printf("a / b (float) = %.2f\n", result);
    
    // Comparison operators
    printf("a == b: %d\n", a == b);   // Equal to: 0 (false)
    printf("a != b: %d\n", a != b);   // Not equal: 1 (true)
    printf("a > b: %d\n", a > b);     // Greater than: 1
    printf("a < b: %d\n", a < b);     // Less than: 0
    
    // Logical operators
    int x = 1, y = 0;
    printf("x && y: %d\n", x && y);   // Logical AND: 0
    printf("x || y: %d\n", x || y);   // Logical OR: 1
    printf("!x: %d\n", !x);           // Logical NOT: 0
    
    // Bitwise operators
    unsigned int num1 = 5;  // Binary: 0101
    unsigned int num2 = 3;  // Binary: 0011
    
    printf("num1 & num2: %u\n", num1 & num2);  // AND: 1 (0001)
    printf("num1 | num2: %u\n", num1 | num2);  // OR: 7 (0111)
    printf("num1 ^ num2: %u\n", num1 ^ num2);  // XOR: 6 (0110)
    printf("~num1: %u\n", ~num1);              // NOT
    printf("num1 << 1: %u\n", num1 << 1);      // Left shift: 10 (1010)
    printf("num1 >> 1: %u\n", num1 >> 1);      // Right shift: 2 (0010)
    
    // Increment and decrement operators
    int count = 5;
    printf("count: %d\n", count);
    printf("++count: %d\n", ++count);  // Pre-increment: 6
    printf("count++: %d\n", count++);  // Post-increment: 6 (then becomes 7)
    printf("count: %d\n", count);      // Current value: 7
    
    return 0;
}

#include <stdio.h>

int main() {
    int number;
    
    printf("Enter a number: ");
    scanf("%d", &number);
    
    // If-else if-else statement
    if (number > 0) {
        printf("%d is positive\n", number);
    } else if (number < 0) {
        printf("%d is negative\n", number);
    } else {
        printf("The number is zero\n");
    }
    
    // Switch statement
    printf("Enter a grade (A, B, C, D, F): ");
    char grade;
    scanf(" %c", &grade);  // Note the space before %c to skip whitespace
    
    switch (grade) {
        case 'A':
            printf("Excellent!\n");
            break;
        case 'B':
            printf("Good job!\n");
            break;
        case 'C':
            printf("Average\n");
            break;
        case 'D':
            printf("Needs improvement\n");
            break;
        case 'F':
            printf("Failed\n");
            break;
        default:
            printf("Invalid grade\n");
    }
    
    // For loop
    printf("Counting 1 to 5 with for loop:\n");
    for (int i = 1; i <= 5; i++) {
        printf("%d ", i);
    }
    printf("\n");
    
    // While loop
    printf("Counting 1 to 3 with while loop:\n");
    int count = 1;
    while (count <= 3) {
        printf("%d ", count);
        count++;
    }
    printf("\n");
    
    // Do-while loop (executes at least once)
    printf("Do-while loop example:\n");
    int input;
    do {
        printf("Enter a positive number: ");
        scanf("%d", &input);
    } while (input <= 0);
    printf("You entered: %d\n", input);
    
    // Nested loops
    printf("Multiplication table (1-3):\n");
    for (int i = 1; i <= 3; i++) {
        for (int j = 1; j <= 3; j++) {
            printf("%d x %d = %d\t", i, j, i * j);
        }
        printf("\n");
    }
    
    // Break and continue
    printf("Break and continue example:\n");
    for (int i = 1; i <= 10; i++) {
        if (i == 3) {
            continue;  // Skip iteration
        }
        if (i == 8) {
            break;     // Exit loop
        }
        printf("%d ", i);
    }
    printf("\n");
    
    return 0;
}

#include <stdio.h>

int main() {
    // Array declaration and initialization
    int numbers[5] = {10, 20, 30, 40, 50};
    float temperatures[7] = {25.5, 26.0, 24.8, 23.9, 25.2, 26.1, 24.5};
    char vowels[] = {'A', 'E', 'I', 'O', 'U'};  // Size determined automatically
    
    // Accessing array elements
    printf("First number: %d\n", numbers[0]);
    printf("Third temperature: %.1f\n", temperatures[2]);
    printf("Second vowel: %c\n", vowels[1]);
    
    // Modifying array elements
    numbers[0] = 100;
    temperatures[3] = 27.8;
    
    // Printing all elements
    printf("All numbers: ");
    for (int i = 0; i < 5; i++) {
        printf("%d ", numbers[i]);
    }
    printf("\n");
    
    // Calculating array sum and average
    int sum = 0;
    for (int i = 0; i < 5; i++) {
        sum += numbers[i];
    }
    float average = (float)sum / 5;
    printf("Sum: %d, Average: %.2f\n", sum, average);
    
    // Finding maximum and minimum
    int max = numbers[0];
    int min = numbers[0];
    for (int i = 1; i < 5; i++) {
        if (numbers[i] > max) {
            max = numbers[i];
        }
        if (numbers[i] < min) {
            min = numbers[i];
        }
    }
    printf("Max: %d, Min: %d\n", max, min);
    
    // Multi-dimensional arrays (2D arrays)
    int matrix[3][3] = {
        {1, 2, 3},
        {4, 5, 6},
        {7, 8, 9}
    };
    
    printf("2D Array (Matrix):\n");
    for (int i = 0; i < 3; i++) {
        for (int j = 0; j < 3; j++) {
            printf("%d ", matrix[i][j]);
        }
        printf("\n");
    }
    
    // Character arrays (strings)
    char name[] = "John Doe";
    char greeting[50] = "Hello, ";
    
    printf("Name: %s\n", name);
    printf("Length of name: %lu\n", sizeof(name) - 1);  // -1 for null terminator
    
    // String manipulation
    int length = 0;
    while (name[length] != '\0') {
        length++;
    }
    printf("Manual length calculation: %d\n", length);
    
    return 0;
}

2. Functions & Program Structure

#include <stdio.h>

// Function declaration (prototype)
int add(int a, int b);
void greet(char name[]);
int factorial(int n);
float calculateAverage(int arr[], int size);

// Main function
int main() {
    // Function calls
    int result = add(5, 3);
    printf("5 + 3 = %d\n", result);
    
    greet("Alice");
    
    int fact = factorial(5);
    printf("Factorial of 5: %d\n", fact);
    
    int numbers[] = {10, 20, 30, 40, 50};
    float avg = calculateAverage(numbers, 5);
    printf("Average: %.2f\n", avg);
    
    return 0;
}

// Function definitions

// Function that returns a value
int add(int a, int b) {
    return a + b;
}

// Function that doesn't return a value (void)
void greet(char name[]) {
    printf("Hello, %s!\n", name);
}

// Recursive function
int factorial(int n) {
    if (n == 0 || n == 1) {
        return 1;
    }
    return n * factorial(n - 1);
}

// Function with array parameter
float calculateAverage(int arr[], int size) {
    int sum = 0;
    for (int i = 0; i < size; i++) {
        sum += arr[i];
    }
    return (float)sum / size;
}

#include <stdio.h>

// Different parameter types
int multiply(int a, int b);
double power(double base, int exponent);
void swap(int *a, int *b);  // Pointer parameters
int stringLength(const char str[]);  // Const parameter

int main() {
    // Basic function calls
    int product = multiply(4, 5);
    printf("4 * 5 = %d\n", product);
    
    double result = power(2.0, 3);
    printf("2.0 ^ 3 = %.2f\n", result);
    
    // Demonstrating pass by value vs pass by reference
    int x = 10, y = 20;
    printf("Before swap: x = %d, y = %d\n", x, y);
    swap(&x, &y);  // Pass addresses
    printf("After swap: x = %d, y = %d\n", x, y);
    
    // String function
    char text[] = "Hello, World!";
    int len = stringLength(text);
    printf("Length of '%s': %d\n", text, len);
    
    // Function with multiple return points
    int number = -5;
    int absValue = absolute(number);
    printf("Absolute value of %d: %d\n", number, absValue);
    
    return 0;
}

int multiply(int a, int b) {
    return a * b;
}

double power(double base, int exponent) {
    double result = 1.0;
    for (int i = 0; i < exponent; i++) {
        result *= base;
    }
    return result;
}

// Pass by reference using pointers
void swap(int *a, int *b) {
    int temp = *a;
    *a = *b;
    *b = temp;
}

int stringLength(const char str[]) {
    int length = 0;
    while (str[length] != '\0') {
        length++;
    }
    return length;
}

int absolute(int num) {
    if (num < 0) {
        return -num;
    }
    return num;
}

#include <stdio.h>

// Global variable - accessible from any function
int globalVar = 100;

// Static variable - persists between function calls
void counter() {
    static int count = 0;  // Static local variable
    count++;
    printf("Counter: %d\n", count);
}

// Function demonstrating different scopes
void scopeDemo() {
    int localVar = 50;  // Local variable
    printf("Inside scopeDemo - localVar: %d\n", localVar);
    printf("Inside scopeDemo - globalVar: %d\n", globalVar);
    
    // Block scope
    {
        int blockVar = 25;  // Only accessible within this block
        printf("Inside block - blockVar: %d\n", blockVar);
    }
    // printf("blockVar: %d\n", blockVar);  // This would cause error
}

// External variable example
extern int externalVar;  // Declared in another file

int main() {
    int localVar = 10;  // Local to main
    
    printf("Global variable: %d\n", globalVar);
    printf("Local variable in main: %d\n", localVar);
    
    // Modify global variable
    globalVar = 200;
    printf("Modified global variable: %d\n", globalVar);
    
    // Demonstrate static variable
    printf("\nStatic variable demonstration:\n");
    counter();
    counter();
    counter();
    
    // Demonstrate scope
    printf("\nScope demonstration:\n");
    scopeDemo();
    
    // Register variable (suggestion to store in CPU register)
    register int regVar = 999;
    printf("Register variable: %d\n", regVar);
    
    return 0;
}

3. Pointers & Memory Management

#include <stdio.h>

int main() {
    int number = 42;
    float price = 19.99;
    char letter = 'A';
    
    // Pointer declarations
    int *ptr_number = &number;     // Pointer to integer
    float *ptr_price = &price;     // Pointer to float
    char *ptr_letter = &letter;    // Pointer to char
    
    // Printing values and addresses
    printf("Variable values:\n");
    printf("number: %d\n", number);
    printf("price: %.2f\n", price);
    printf("letter: %c\n", letter);
    
    printf("\nMemory addresses:\n");
    printf("&number: %p\n", (void*)&number);
    printf("&price: %p\n", (void*)&price);
    printf("&letter: %p\n", (void*)&letter);
    
    printf("\nPointer values (same as addresses above):\n");
    printf("ptr_number: %p\n", (void*)ptr_number);
    printf("ptr_price: %p\n", (void*)ptr_price);
    printf("ptr_letter: %p\n", (void*)ptr_letter);
    
    printf("\nDereferencing pointers (accessing values):\n");
    printf("*ptr_number: %d\n", *ptr_number);
    printf("*ptr_price: %.2f\n", *ptr_price);
    printf("*ptr_letter: %c\n", *ptr_letter);
    
    // Modifying values through pointers
    *ptr_number = 100;
    *ptr_price = 29.99;
    *ptr_letter = 'B';
    
    printf("\nAfter modification through pointers:\n");
    printf("number: %d\n", number);
    printf("price: %.2f\n", price);
    printf("letter: %c\n", letter);
    
    // Pointer arithmetic
    int arr[] = {10, 20, 30, 40, 50};
    int *ptr_arr = arr;  // Points to first element
    
    printf("\nArray elements using pointer arithmetic:\n");
    for (int i = 0; i < 5; i++) {
        printf("arr[%d] = %d (address: %p)\n", i, *(ptr_arr + i), (void*)(ptr_arr + i));
    }
    
    // Pointer to pointer
    int value = 500;
    int *ptr1 = &value;
    int **ptr2 = &ptr1;
    
    printf("\nPointer to pointer example:\n");
    printf("value: %d\n", value);
    printf("*ptr1: %d\n", *ptr1);
    printf("**ptr2: %d\n", **ptr2);
    printf("ptr1: %p, ptr2: %p\n", (void*)ptr1, (void*)ptr2);
    
    return 0;
}

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

int main() {
    // Dynamic memory allocation for single variable
    int *dynamicInt = (int*)malloc(sizeof(int));
    if (dynamicInt == NULL) {
        printf("Memory allocation failed!\n");
        return 1;
    }
    *dynamicInt = 42;
    printf("Dynamic integer: %d\n", *dynamicInt);
    
    // Dynamic array allocation
    int size;
    printf("Enter the size of the array: ");
    scanf("%d", &size);
    
    int *dynamicArray = (int*)malloc(size * sizeof(int));
    if (dynamicArray == NULL) {
        printf("Memory allocation failed!\n");
        free(dynamicInt);
        return 1;
    }
    
    // Initialize array
    for (int i = 0; i < size; i++) {
        dynamicArray[i] = (i + 1) * 10;
    }
    
    printf("Dynamic array elements: ");
    for (int i = 0; i < size; i++) {
        printf("%d ", dynamicArray[i]);
    }
    printf("\n");
    
    // Reallocating memory (resizing array)
    int newSize;
    printf("Enter new size for array: ");
    scanf("%d", &newSize);
    
    int *resizedArray = (int*)realloc(dynamicArray, newSize * sizeof(int));
    if (resizedArray == NULL) {
        printf("Memory reallocation failed!\n");
        free(dynamicArray);
        free(dynamicInt);
        return 1;
    }
    dynamicArray = resizedArray;
    
    // Initialize new elements if array grew
    if (newSize > size) {
        for (int i = size; i < newSize; i++) {
            dynamicArray[i] = (i + 1) * 10;
        }
    }
    
    printf("Resized array elements: ");
    for (int i = 0; i < newSize; i++) {
        printf("%d ", dynamicArray[i]);
    }
    printf("\n");
    
    // Using calloc (initializes memory to zero)
    int *zeroArray = (int*)calloc(5, sizeof(int));
    printf("Calloc array (should be zeros): ");
    for (int i = 0; i < 5; i++) {
        printf("%d ", zeroArray[i]);
    }
    printf("\n");
    
    // Free all allocated memory
    free(dynamicInt);
    free(dynamicArray);
    free(zeroArray);
    
    printf("All memory freed successfully.\n");
    
    return 0;
}

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

// Function to calculate string length using pointers
int stringLength(const char *str) {
    const char *ptr = str;
    while (*ptr != '\0') {
        ptr++;
    }
    return ptr - str;
}

// Function to copy string using pointers
void stringCopy(char *dest, const char *src) {
    while (*src != '\0') {
        *dest = *src;
        dest++;
        src++;
    }
    *dest = '\0';
}

// Function to reverse string using pointers
void reverseString(char *str) {
    char *start = str;
    char *end = str;
    
    // Find the end of the string
    while (*end != '\0') {
        end++;
    }
    end--;  // Move back from null terminator
    
    // Reverse the string
    while (start < end) {
        char temp = *start;
        *start = *end;
        *end = temp;
        start++;
        end--;
    }
}

int main() {
    // Array and pointer relationship
    int arr[] = {10, 20, 30, 40, 50};
    int *ptr = arr;  // ptr points to first element
    
    printf("Array elements using different notations:\n");
    for (int i = 0; i < 5; i++) {
        printf("arr[%d] = %d, *(arr + %d) = %d, *(ptr + %d) = %d\n", 
               i, arr[i], i, *(arr + i), i, *(ptr + i));
    }
    
    // String operations with pointers
    char original[] = "Hello, World!";
    char copied[50];
    
    printf("\nString operations with pointers:\n");
    printf("Original string: %s\n", original);
    printf("Length using pointer function: %d\n", stringLength(original));
    
    stringCopy(copied, original);
    printf("Copied string: %s\n", copied);
    
    reverseString(copied);
    printf("Reversed copied string: %s\n", copied);
    
    // Array of pointers
    char *fruits[] = {"Apple", "Banana", "Orange", "Grape", "Mango"};
    int numFruits = sizeof(fruits) / sizeof(fruits[0]);
    
    printf("\nArray of pointers to strings:\n");
    for (int i = 0; i < numFruits; i++) {
        printf("Fruit %d: %s\n", i + 1, fruits[i]);
    }
    
    // Pointer to array
    int (*ptrToArray)[5] = &arr;
    printf("\nPointer to entire array:\n");
    printf("First element: %d\n", (*ptrToArray)[0]);
    printf("Size of ptrToArray: %lu\n", sizeof(ptrToArray));
    
    return 0;
}