C Programming Home

Welcome to the LearnX C Programming course! This course is designed to take you from a complete beginner to a professional-level C programmer. You'll learn C syntax, memory management, advanced functions, file handling, structures, pointers, and real-world project applications.

C is a versatile, high-performance programming language developed in the 1970s. It's widely used for system-level programming, building operating systems, embedded devices, and performance-critical applications. Mastering C gives you a solid foundation for learning modern languages like C++ and Python.

Why Learn C?

C teaches you how computers manage memory, processes, and low-level operations, which is essential for software engineering, firmware development, and embedded systems. Understanding C also improves debugging skills, logical thinking, and performance optimization.

/* Simple Hello World program in C */
#include <stdio.h>

int main() {
    printf("Welcome to LearnX C Programming!\\n");
    return 0;
}
    

Real-World Use Case

This "Hello World" example introduces you to compiling and running C programs, foundational for building more complex applications such as calculators, file parsers, and embedded system utilities.

Common Mistakes

• Forgetting to include <stdio.h>
• Missing the semicolon at the end of statements
• Using improper quotes or escape characters in strings

Best Practices

• Always include necessary header files
• Use consistent indentation for readability
• Comment your code for clarity

C Introduction

C is a powerful general-purpose programming language that has influenced almost every modern programming language. Its simplicity and efficiency make it ideal for low-level system programming and high-performance applications.

C code is compiled, not interpreted, which allows programs to run quickly. It provides precise control over system resources such as memory and CPU, making it a go-to language for system programming, embedded systems, and performance-critical applications.

Syntax Highlights

In C, programs are composed of functions, with main() being the entry point. C uses semicolons to terminate statements, curly braces for code blocks, and supports variables, loops, conditionals, and user-defined functions.

#include <stdio.h>

int main() {
    int age = 25;
    printf("Your age is %d\\n", age);
    return 0;
}
    

Real-World Use Case

Variables like int age are fundamental in programs such as user registration forms, calculators, or inventory tracking systems.

Common Mistakes

• Using undeclared variables
• Incorrect format specifiers in printf()

Best Practices

• Use meaningful variable names
• Always initialize variables
• Follow consistent formatting for readability

Getting Started with C

Before writing your first C program, you need a compiler and a basic understanding of C program structure. Modern editors like VS Code, Code::Blocks, or online compilers like Replit make it easy to start coding.

A typical C program includes preprocessor directives, a main() function, and statements. Programs are compiled into machine code before execution, ensuring fast performance and efficiency.

#include <stdio.h>

int main() {
    printf("C programming setup successful!\\n");
    return 0;
}
    

Real-World Use Case

Setting up your environment is the first step to building real-world applications like file parsers, embedded system firmware, and software utilities.

Common Mistakes

• Not installing the compiler correctly
• Incorrect file extension (.c required)
• Forgetting to compile before running

Best Practices

• Use an IDE or online compiler for convenience
• Keep your first programs simple
• Check compiler output for warnings and errors

C Syntax

C programs follow a structured syntax that is easy to learn. Understanding the rules of syntax is essential to write error-free programs and debug efficiently.

C syntax defines how programs should be written. Each statement ends with a semicolon (;), and code blocks are enclosed in curly braces ({ }). C is case-sensitive, so Variable and variable are treated as different identifiers.

#include <stdio.h>

int main() {
    int num = 10;
    if (num > 5) {
        printf("Number is greater than 5\\n");
    }
    return 0;
}
    

Real-World Use Case

Proper syntax is critical in projects like calculators, decision-making programs, and any software that depends on conditional logic.

Common Mistakes

• Missing semicolons
• Mismatched braces
• Using incorrect case for variables or functions

Best Practices

• Indent your code consistently
• Comment blocks for readability
• Compile frequently to catch syntax errors early

C Output

Output in C is primarily handled using the printf() function, which allows you to display text, variables, and formatted data to the console.

The printf() function is versatile. You can combine text and variables using format specifiers. Escape sequences allow you to format output for readability.

#include <stdio.h>

int main() {
    int age = 22;
    char grade = 'A';
    printf("Age: %d\\n", age);
    printf("Grade: %c\\n", grade);
    printf("Welcome to LearnX!\\n");
    return 0;
}
    

Real-World Use Case

Console output is used in debugging, creating command-line tools, and displaying program results in real-time.

Common Mistakes

• Using wrong format specifiers
• Forgetting escape sequences for new lines
• Passing variables without matching specifiers

Best Practices

• Always match format specifiers with variable types
• Use \n to create clean, readable output
• Test output formatting with multiple variable types

C Comments

Comments are notes in your code that the compiler ignores. They are essential for documenting logic, making code readable, and helping with debugging.

Proper commenting makes your code easier to maintain. While single-line comments are ideal for brief explanations, multi-line comments are useful for documenting functions, loops, or algorithms.

#include <stdio.h>

int main() {
    // This is a single-line comment
    printf("Hello, LearnX!\\n");

    /*
      This is a multi-line comment
      explaining the next line of code
    */
    printf("C programming is fun!\\n");
    return 0;
}
    

Real-World Use Case

Comments are used in professional projects to explain algorithms, mark TODO items, and document code for future developers or teammates.

Common Mistakes

• Forgetting to close multi-line comments
• Using comments excessively for obvious code

Best Practices

• Write meaningful comments that explain why, not just what
• Keep comments concise
• Update comments when code changes

C Variables

Variables are named memory locations used to store data. They allow programs to manipulate and track information dynamically.

Variables must be declared before use. A declaration specifies the type and name of the variable. Proper naming conventions improve readability and prevent conflicts.

#include <stdio.h>

int main() {
    int age = 30;         // Integer variable
    float salary = 55000.50; // Floating point variable
    char grade = 'A';     // Character variable

    printf("Age: %d\\n", age);
    printf("Salary: %.2f\\n", salary);
    printf("Grade: %c\\n", grade);
    return 0;
}
    

Real-World Use Case

Variables are used in inventory systems, payroll calculations, game scores, and any program that requires storing and processing data dynamically.

Common Mistakes

• Using uninitialized variables
• Assigning incompatible data types
• Incorrect variable scope usage

Best Practices

• Initialize variables at declaration
• Use descriptive variable names
• Minimize global variables

C Data Types

C provides several built-in data types to store different kinds of data. Choosing the correct type ensures efficient memory usage and accurate computations.

Understanding data types is critical for memory management. For example, an int typically uses 4 bytes, while a char uses 1 byte. Using the right type helps prevent overflow and data loss.

#include <stdio.h>

int main() {
    int age = 28;
    float gpa = 3.75;
    double salary = 75000.55;
    char grade = 'B';

    printf("Age: %d\\n", age);
    printf("GPA: %.2f\\n", gpa);
    printf("Salary: %.2f\\n", salary);
    printf("Grade: %c\\n", grade);
    return 0;
}
    

Real-World Use Case

Data types are used in payroll systems, grading systems, scientific calculations, and any program requiring numeric or textual data storage.

Common Mistakes

• Mismatched data types
• Memory overflow due to large numbers in small types
• Incorrect type casting without conversion

Best Practices

• Select data types based on memory and precision needs
• Use float for decimal numbers, double for higher precision
• Avoid unnecessary type conversions

C Type Conversion

Type conversion in C allows changing a variable from one data type to another. It can be done implicitly (type promotion) or explicitly (type casting).

Implicit conversion happens when C automatically converts smaller types to larger types in expressions, such as int → float. Explicit conversion uses casting operators to manually convert a variable.

#include <stdio.h>

int main() {
    int num = 10;
    float result;

    // Implicit conversion
    result = num + 5.5;
    printf("Result: %.2f\\n", result);

    // Explicit conversion
    result = (float)num / 4;
    printf("Result after casting: %.2f\\n", result);
    return 0;
}
    

Real-World Use Case

Type conversion is essential in financial applications, scientific calculations, and any program where precise numeric operations are required.

Common Mistakes

• Loss of precision during type conversion
• Using incorrect casting that can cause runtime errors
• Relying only on implicit conversion for critical calculations

Best Practices

• Use explicit casting when necessary
• Avoid unnecessary conversions to maintain precision
• Be aware of type sizes to prevent overflow or truncation

C Constants

Constants are fixed values in C that do not change during program execution. They are useful for values that remain the same, improving readability and reducing errors.

Constants are often used for values like Pi, maximum array sizes, or configuration parameters that should remain fixed throughout the program.

#include <stdio.h>
#define PI 3.14159

int main() {
    const int DAYS_IN_WEEK = 7;
    printf("PI: %.2f\\n", PI);
    printf("Days in a week: %d\\n", DAYS_IN_WEEK);
    return 0;
}
    

Real-World Use Case

Constants are used in physics calculations (like Pi), software configuration settings, and fixed system limits (like array sizes).

Common Mistakes

• Attempting to modify a constant
• Not using descriptive names for constants

Best Practices

• Use const for typed constants
• Use #define for symbolic constants
• Write descriptive names in uppercase letters

C Operators

Operators in C are symbols that perform operations on variables and values. They form the core of all computations and logic in a program.

Operators allow performing calculations, comparisons, and logical decisions. Mastering operators is essential for programming, algorithms, and problem-solving.

#include <stdio.h>

int main() {
    int a = 10, b = 5;
    printf("Sum: %d\\n", a + b);
    printf("Difference: %d\\n", a - b);
    printf("Product: %d\\n", a * b);
    printf("Division: %d\\n", a / b);
    printf("Remainder: %d\\n", a % b);
    printf("Is a > b? %d\\n", a > b);
    printf("Logical AND (a > 5 && b < 10): %d\\n", a > 5 && b < 10);
    return 0;
}
    

Real-World Use Case

Operators are used in calculations, decision-making, and building algorithms like sorting, searching, or financial computations.

Common Mistakes

• Using assignment = instead of comparison ==
• Mixing logical operators without parentheses
• Division by zero errors

Best Practices

• Use parentheses to clarify complex expressions
• Check operator precedence rules
• Comment tricky operations for readability

C Booleans

C does not have a dedicated boolean type in standard C (pre-C99). Booleans are represented using integers: 0 for false, non-zero for true. C99 introduced _Bool and stdbool.h for clarity.

Boolean logic is essential in decision-making, loops, and validating conditions. Using stdbool.h improves code readability by allowing true and false keywords.

#include <stdio.h>
#include <stdbool.h>

int main() {
    bool isLoggedIn = true;
    if (isLoggedIn) {
        printf("User is logged in\\n");
    } else {
        printf("User is not logged in\\n");
    }
    return 0;
}
    

Real-World Use Case

Booleans are used in login validation, feature flags, game logic, and any conditional checks in programs.

Common Mistakes

• Assuming non-zero integers are always 1
• Using integers instead of booleans for clarity

Best Practices

• Use bool for readability
• Use logical operators instead of numeric tricks
• Comment complex boolean expressions

C If...Else

The if and else statements are used for conditional execution of code blocks. They are fundamental for decision-making in C programs.

Conditional statements allow programs to respond differently based on input or computation. Nested and combined conditions enable more complex decision-making.

#include <stdio.h>

int main() {
    int score = 85;
    if (score >= 90) {
        printf("Grade: A\\n");
    } else if (score >= 75) {
        printf("Grade: B\\n");
    } else if (score >= 60) {
        printf("Grade: C\\n");
    } else {
        printf("Grade: F\\n");
    }
    return 0;
}
    

Real-World Use Case

If-else statements are used in grading systems, authentication checks, and conditional workflows in software applications.

Common Mistakes

• Incorrect comparison operators
• Skipping braces for multi-line blocks

Best Practices

• Always use braces for clarity
• Indent nested blocks consistently
• Keep conditions simple and readable

C Switch

The switch statement is used to perform multiple selections based on the value of a variable. It is an alternative to multiple if-else statements.

Switch statements are ideal for handling menu selections, commands, or any situation with multiple discrete options. Each case must be unique and followed by a break to prevent fall-through.

#include <stdio.h>

int main() {
    int day = 3;
    switch(day) {
        case 1:
            printf("Monday\\n");
            break;
        case 2:
            printf("Tuesday\\n");
            break;
        case 3:
            printf("Wednesday\\n");
            break;
        default:
            printf("Other day\\n");
    }
    return 0;
}
    

Real-World Use Case

Switch statements are commonly used in menu-driven programs, CLI tools, and embedded device state machines.

Common Mistakes

• Forgetting the break statement
• Duplicate case labels

Best Practices

• Use default to handle unexpected values
• Keep cases simple and readable
• Avoid overly complex logic in a single switch

C While Loop

The while loop allows repeated execution of a block of code as long as a condition is true. It's ideal when the number of iterations is unknown beforehand.

#include <stdio.h>

int main() {
    int count = 1;
    while(count <= 5) {
        printf("Count: %d\\n", count);
        count++;
    }
    return 0;
}
    

Real-World Use Case

While loops are used for reading input until a sentinel value is entered, retrying network requests, or waiting for a condition in embedded systems.

Common Mistakes

• Infinite loops due to not updating the loop variable
• Incorrect condition logic

Best Practices

• Always ensure the loop condition will eventually become false
• Keep the loop body concise
• Use comments for complex loop logic

C For Loop

The for loop is used when the number of iterations is known. It combines initialization, condition, and increment/decrement in one concise statement.

#include <stdio.h>

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

Real-World Use Case

For loops are widely used in processing arrays, generating reports, and iterating over known ranges like days of the week or menu options.

Common Mistakes

• Off-by-one errors in loop conditions
• Incorrect increment/decrement

Best Practices

• Keep loop variables local to the loop whenever possible
• Use descriptive variable names like i, j, index appropriately
• Test edge conditions for loops

C Break / Continue

The break and continue statements control loop execution. break exits the loop entirely, while continue skips the current iteration.

#include <stdio.h>

int main() {
    for(int i = 1; i <= 10; i++) {
        if(i == 7) break; // exit loop at 7
        if(i % 2 == 0) continue; // skip even numbers
        printf("Number: %d\\n", i);
    }
    return 0;
}
    

Real-World Use Case

Break and continue are used in menu navigation, skipping invalid input, and early exit from loops for performance optimization.

Common Mistakes

• Using break/continue outside a loop (syntax error)
• Overusing break can reduce readability

Best Practices

• Use break/continue sparingly for clarity
• Comment reasons for exiting/skipping iterations
• Keep loop conditions simple

C Arrays

Arrays are collections of elements of the same type stored in contiguous memory locations. They allow efficient storage and access to multiple values using indices.

#include <stdio.h>

int main() {
    int numbers[5] = {10, 20, 30, 40, 50};
    for(int i = 0; i < 5; i++) {
        printf("Number[%d]: %d\\n", i, numbers[i]);
    }
    return 0;
}
    

Real-World Use Case

Arrays are used for storing sensor data, student marks, inventory quantities, and other sequential datasets.

Common Mistakes

• Accessing out-of-bounds indices
• Incorrect array size declaration

Best Practices

• Always check array bounds
• Use constants for array sizes
• Use loops for iteration, not manual access

C Strings

Strings in C are arrays of characters terminated by a null character '\0'. They are used to handle text and textual data.

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

int main() {
    char name[20] = "LearnX";
    printf("Name: %s\\n", name);
    printf("Length: %lu\\n", strlen(name));
    return 0;
}
    

Real-World Use Case

Strings are used for usernames, messages, file names, and any text data in software applications.

Common Mistakes

• Forgetting the null terminator
• Buffer overflow due to small array size

Best Practices

• Always allocate enough space for strings
• Use strncpy and snprintf for safe operations
• Use string library functions for manipulation

C Functions

Functions in C allow you to divide a program into smaller, reusable blocks of code. They improve readability, modularity, and maintainability.

#include <stdio.h>

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

int main() {
    greet();
    return 0;
}
    

Real-World Use Case

Functions are used in all modular software, from calculators to web servers, to encapsulate repeated logic like input validation, calculations, or database queries.

Common Mistakes

• Defining functions after main without a prototype
• Incorrect return type

Best Practices

• Use descriptive function names
• Keep functions focused on a single task
• Declare prototypes before main

C Function Parameters

Parameters allow functions to receive data from the caller. They make functions more flexible and reusable.

#include <stdio.h>

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

int main() {
    int result = add(10, 20);
    printf("Result: %d\\n", result);
    return 0;
}
    

Real-World Use Case

Parameters allow calculator functions, data processors, and configuration handlers to work dynamically with different inputs.

Common Mistakes

• Passing wrong type of arguments
• Assuming changes to parameters affect caller (pass-by-value)

Best Practices

• Use const for parameters not modified
• Use pointers for large structures or arrays
• Keep the number of parameters manageable

C Scope

Scope defines where a variable is accessible within a program. Understanding scope prevents naming conflicts and errors.

#include <stdio.h>

int globalVar = 100; // global variable

void func() {
    int localVar = 50; // local variable
    printf("Local: %d\\n", localVar);
    printf("Global: %d\\n", globalVar);
}

int main() {
    func();
    // printf("%d", localVar); // ERROR: localVar not visible here
    return 0;
}
    

Real-World Use Case

Proper scope management avoids bugs in large programs, especially when multiple developers work on the same codebase.

Common Mistakes

• Using a local variable outside its block
• Overusing global variables, leading to hard-to-debug code

Best Practices

• Prefer local variables over global when possible
• Use descriptive names to avoid shadowing
• Limit variable lifetime to necessary scope

C Function Declaration

A function declaration (prototype) informs the compiler about a function’s name, return type, and parameters before its actual definition. It enables calling functions before they are defined.

#include <stdio.h>

// Function declaration
int multiply(int a, int b);

int main() {
    int result = multiply(5, 6);
    printf("Result: %d\\n", result);
    return 0;
}

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

Real-World Use Case

Function declarations are essential for multi-file programs, libraries, and APIs where definitions are separate from the main code.

Common Mistakes

• Forgetting to declare a function before calling it
• Mismatched parameter types between declaration and definition

Best Practices

• Use prototypes for all functions defined after main
• Keep declarations in header files for modularity
• Ensure parameter types match exactly between declaration and definition

C Functions Challenge

This challenge reinforces function usage by combining multiple concepts: parameters, return values, and modular code.

#include <stdio.h>

float celsiusToFahrenheit(float c) {
    return (c * 9 / 5) + 32;
}

int main() {
    float tempC = 25;
    float tempF = celsiusToFahrenheit(tempC);
    printf("%.2f°C = %.2f°F\\n", tempC, tempF);
    return 0;
}
    

Real-World Use Case

Functions challenges simulate tasks like unit converters, calculators, and data processing to solidify understanding of modular code.

Common Mistakes

• Incorrect return type
• Not handling edge cases

Best Practices

• Break problems into small, reusable functions
• Test each function independently
• Use descriptive function names

C Math Functions

C provides standard math functions via math.h for calculations like power, square root, trigonometry, and rounding.

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

int main() {
    double num = 9.0;
    printf("Square root: %.2f\\n", sqrt(num));
    printf("Power: %.2f\\n", pow(num, 3));
    return 0;
}
    

Real-World Use Case

Math functions are used in physics simulations, finance calculations, games, and any numeric-heavy program.

Common Mistakes

• Not including math.h
• Using integer types instead of double for math functions

Best Practices

• Use correct data types
• Always link with -lm when compiling math functions
• Use functions for repeated calculations

C Inline Functions

Inline functions suggest the compiler to replace function calls with the function code, improving performance for small functions.

#include <stdio.h>

inline int square(int x) {
    return x * x;
}

int main() {
    int n = 5;
    printf("Square of %d: %d\\n", n, square(n));
    return 0;
}
    

Real-World Use Case

Inline functions are used in performance-critical code, embedded systems, or math-heavy calculations.

Common Mistakes

• Marking large functions as inline (negates performance)
• Ignoring compiler warnings

Best Practices

• Use for small, frequently called functions
• Do not rely solely on inline for optimization

C Recursion

Recursion occurs when a function calls itself. It's used to solve problems that can be broken into smaller subproblems, like factorials, Fibonacci numbers, or tree traversals.

#include <stdio.h>

int factorial(int n) {
    if(n == 0) return 1; // base case
    return n * factorial(n - 1);
}

int main() {
    int num = 5;
    printf("Factorial of %d: %d\\n", num, factorial(num));
    return 0;
}
    

Real-World Use Case

Recursion is used in algorithms like sorting (quick sort, merge sort), tree traversal, and backtracking problems.

Common Mistakes

• No base case leading to infinite recursion
• Stack overflow due to too many recursive calls

Best Practices

• Always define a clear base case
• Consider iterative solutions for deep recursion
• Use recursion for clarity, not just novelty

C Function Pointers

Function pointers store addresses of functions. They allow dynamic function calls, callbacks, and implementing plugin-like behavior.

#include <stdio.h>

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

int main() {
    int (*operation)(int, int);

    operation = add;
    printf("Add: %d\\n", operation(5, 3));

    operation = multiply;
    printf("Multiply: %d\\n", operation(5, 3));

    return 0;
}
    

Real-World Use Case

Function pointers are used in event-driven programming, callbacks, plugin architectures, and jump tables.

Common Mistakes

• Wrong function signature
• Dereferencing NULL function pointer

Best Practices

• Ensure correct type for function pointers
• Initialize pointers before use
• Comment usage for clarity

C Create Files

File handling in C allows programs to store and retrieve data persistently. To create a file, we use the fopen() function with the appropriate mode.

#include <stdio.h>

int main() {
    FILE *file = fopen("example.txt", "w");
    if(file == NULL) {
        printf("Error creating file.\\n");
        return 1;
    }
    printf("File created successfully.\\n");
    fclose(file);
    return 0;
}
    

Real-World Use Case

Creating files is essential for logging, saving user data, configuration files, and exporting results in applications.

Common Mistakes

• Forgetting to check if fopen() returns NULL
• Not closing the file with fclose()

Best Practices

• Always check file pointer validity
• Close files promptly to free resources
• Use descriptive file names

C Write To Files

Writing to files stores data for later use. We use fprintf(), fputs(), or fwrite() depending on the data type and format.

#include <stdio.h>

int main() {
    FILE *file = fopen("data.txt", "w");
    if(file == NULL) {
        printf("Unable to open file.\\n");
        return 1;
    }

    fprintf(file, "Learn C Programming with LearnX!\\n");
    fputs("This is a sample line.\\n", file);

    printf("Data written to file successfully.\\n");
    fclose(file);
    return 0;
}
    

Real-World Use Case

Writing files is crucial for saving logs, reports, configuration files, and persistent application data.

Common Mistakes

• Writing to a file opened in read mode
• Not checking if write operation succeeded

Best Practices

• Flush the buffer if needed with fflush()
• Always close files after writing
• Handle errors gracefully

C Read Files

Reading files retrieves stored data. Functions like fscanf(), fgets(), and fread() are used depending on the data format.

#include <stdio.h>

int main() {
    char line[100];
    FILE *file = fopen("data.txt", "r");
    if(file == NULL) {
        printf("Unable to open file.\\n");
        return 1;
    }

    while(fgets(line, sizeof(line), file)) {
        printf("%s", line);
    }

    fclose(file);
    return 0;
}
    

Real-World Use Case

Reading files is critical for configuration loading, log analysis, data import, and report generation.

Common Mistakes

• Reading without checking for NULL
• Buffer overflow when reading lines
• Ignoring end-of-file

Best Practices

• Use fgets() instead of gets()
• Validate file pointer and read operation
• Close files promptly

C Structures

Structures in C allow grouping of different data types under a single name. They help organize complex data logically.

#include <stdio.h>

struct Student {
    char name[50];
    int age;
    float marks;
};

int main() {
    struct Student s1 = {"Alice", 20, 88.5};
    printf("Name: %s\\nAge: %d\\nMarks: %.2f\\n", s1.name, s1.age, s1.marks);
    return 0;
}
    

Real-World Use Case

Structures are used to represent entities in databases, employee records, or any grouped data in applications.

Common Mistakes

• Using uninitialized members
• Confusing structure name with variable name

Best Practices

• Always initialize structures
• Use meaningful member names
• Group related data logically

C Structs Challenge

This challenge reinforces understanding of structures by manipulating multiple instances and performing calculations.

#include <stdio.h>

struct Student {
    char name[50];
    float marks;
};

int main() {
    struct Student s1 = {"Alice", 85.0};
    struct Student s2 = {"Bob", 90.0};
    float avg = (s1.marks + s2.marks)/2;
    printf("Average Marks: %.2f\\n", avg);
    return 0;
}
    

C Nested Structures

Structures can contain other structures as members. This is called nesting and is useful for modeling hierarchical data.

#include <stdio.h>

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

struct Student {
    char name[50];
    struct Address addr;
};

int main() {
    struct Student s = {"Alice", {"New York", 10001}};
    printf("Name: %s\\nCity: %s\\nZip: %d\\n", s.name, s.addr.city, s.addr.zip);
    return 0;
}
    

C Structs & Pointers

Structures can be accessed using pointers, which is more efficient for large structures and dynamic memory usage.

#include <stdio.h>

struct Student {
    char name[50];
    int age;
};

int main() {
    struct Student s = {"Alice", 20};
    struct Student *ptr = &s;

    printf("Name: %s\\nAge: %d\\n", ptr->name, ptr->age);
    return 0;
}
    

C Unions

Unions are similar to structures but share the same memory for all members. Only one member can hold a value at a time.

#include <stdio.h>

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

int main() {
    union Data d;
    d.i = 10;
    printf("Integer: %d\\n", d.i);

    d.f = 220.5;
    printf("Float: %.2f\\n", d.f);

    return 0;
}
    

C typedef

The typedef keyword creates an alias for existing data types, making code easier to read and maintain.

#include <stdio.h>

typedef struct {
    char name[50];
    int age;
} Student;

int main() {
    Student s = {"Alice", 20};
    printf("Name: %s\\nAge: %d\\n", s.name, s.age);
    return 0;
}
    

C Struct Padding

Struct padding is added by the compiler to align members for faster access. Awareness of padding is important for memory optimization.

#include <stdio.h>

struct PackedStudent {
    char a;
    int b;
};

int main() {
    printf("Size of struct: %zu bytes\\n", sizeof(struct PackedStudent));
    return 0;
}
    

C Enums

Enumerations (enums) allow defining a set of named integer constants. They improve code readability and maintainability for related values.

#include <stdio.h>

enum Days { Sunday, Monday, Tuesday, Wednesday, Thursday, Friday, Saturday };

int main() {
    enum Days today = Wednesday;
    printf("Day number: %d\\n", today); // 3
    return 0;
}
    

Real-World Use Case

Enums are used for state machines, menu options, error codes, or any set of related constants in programs.

Common Mistakes

• Using enums without type safety in comparisons
• Assigning invalid values outside enum

Best Practices

• Use enums instead of magic numbers
• Give meaningful names to enum constants
• Use typedef for enum aliases for cleaner syntax

C Memory Management

C provides dynamic memory allocation functions for efficient memory usage, especially when the program size or data is not known at compile time.

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

int main() {
    int n = 5;
    int *arr = (int*)malloc(n * sizeof(int));
    if(arr == NULL) {
        printf("Memory allocation failed.\\n");
        return 1;
    }

    for(int i=0; i<n; i++) {
        arr[i] = i * 10;
        printf("%d ", arr[i]);
    }

    free(arr);
    return 0;
}
    

Real-World Use Case

Dynamic memory is essential in applications like data structures (linked lists, trees), large arrays, and when handling user input of unknown size.

Common Mistakes

• Not checking if allocation returned NULL
• Memory leaks by forgetting to call free()
• Accessing memory after it is freed (dangling pointers)

Best Practices

• Always initialize pointers
• Use free() for every malloc()/calloc()/realloc()
• Consider smart memory management in larger projects

C Errors

Error handling is crucial in C programming to ensure programs behave predictably under unexpected situations.

#include <stdio.h>

int main() {
    int x = 5, y = 0;

    if(y == 0) {
        printf("Error: Division by zero!\\n");
    } else {
        printf("Result: %d\\n", x/y);
    }

    return 0;
}
    

Real-World Use Case

Essential for financial calculations, file operations, and network applications where incorrect operations can crash programs.

Common Mistakes

• Ignoring runtime errors
• Not validating inputs

Best Practices

• Always check return values of functions
• Provide meaningful error messages
• Prevent errors proactively using conditions and validations

C Error Challenge

Practice identifying and fixing errors in the following code snippet.

#include <stdio.h>

int main() {
    int numbers[5] = {1,2,3,4,5};
    for(int i=0; i<6; i++) { // Index out of bounds
        printf("%d\\n", numbers[i]);
    }
    return 0;
}
    

C Debugging

Debugging involves finding and fixing errors in your code. Common techniques include using print statements, debuggers, and analyzing program flow.

C NULL

The NULL pointer represents a pointer that does not point to any valid memory. Always check pointers before dereferencing.

#include <stdio.h>

int main() {
    int *ptr = NULL;

    if(ptr != NULL) {
        *ptr = 10;
    } else {
        printf("Pointer is NULL, cannot dereference.\\n");
    }

    return 0;
}
    

C Error Handling

Proper error handling prevents crashes and ensures programs can recover from failures. Use checks, return codes, and messages consistently.

C Input Validation

Validate user input to avoid unexpected behavior. Check ranges, types, and limits for safety.

#include <stdio.h>

int main() {
    int age;
    printf("Enter age: ");
    if(scanf("%d", &age) != 1) {
        printf("Invalid input!\\n");
        return 1;
    }

    if(age < 0 || age > 120) {
        printf("Age out of range!\\n");
    } else {
        printf("Valid age: %d\\n", age);
    }

    return 0;
}
    

C Date

The time.h library provides functions to handle date and time in C programs, useful for timestamps, logging, or scheduling tasks.

#include <stdio.h>
#include <time.h>

int main() {
    time_t now = time(NULL);
    struct tm *t = localtime(&now);

    printf("Current Date: %02d/%02d/%d\\n", t->tm_mday, t->tm_mon + 1, t->tm_year + 1900);
    printf("Current Time: %02d:%02d:%02d\\n", t->tm_hour, t->tm_min, t->tm_sec);
    return 0;
}
    

C Random Numbers

The rand() function generates pseudo-random numbers. Seed with srand() to vary the sequence each run.

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

int main() {
    srand(time(NULL));

    for(int i=0; i<5; i++) {
        printf("%d ", rand() % 100); // Random number between 0-99
    }
    return 0;
}
    

C Macros

Macros allow defining constants or inline code with #define. They are preprocessor directives evaluated before compilation.

#include <stdio.h>
#define PI 3.14159
#define SQUARE(x) ((x)*(x))

int main() {
    printf("PI: %.2f\\n", PI);
    printf("Square of 5: %d\\n", SQUARE(5));
    return 0;
}
    

C Organize Code

Organizing code with functions, headers, and modular files improves readability, maintainability, and debugging efficiency.

C Storage Classes

Storage classes define the scope, lifetime, and visibility of variables in C.

C Bitwise Operators

Bitwise operators allow manipulation of individual bits in integers, essential for low-level programming and embedded systems.

#include <stdio.h>

int main() {
    unsigned int a = 5, b = 9; // 0101 and 1001
    printf("a & b = %d\\n", a & b);
    printf("a | b = %d\\n", a | b);
    printf("a ^ b = %d\\n", a ^ b);
    printf("~a = %d\\n", ~a);
    return 0;
}
    

C Fixed-width Integers

Fixed-width integers from <stdint.h> provide precise control over integer sizes for portability and embedded systems.

#include <stdio.h>
#include <stdint.h>

int main() {
    int8_t small = 127;
    uint32_t large = 100000;
    printf("Small: %d, Large: %u\\n", small, large);
    return 0;
}
    

C Projects

This section contains mini-projects that combine multiple C concepts, helping you practice real-world programming skills.

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

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

int main() {
    FILE *fptr = fopen("students.txt", "w");
    if(fptr == NULL) { printf("Error opening file\\n"); return 1; }

    struct Student s1 = {1, "Alice"};
    struct Student s2 = {2, "Bob"};

    fprintf(fptr, "%d %s\\n", s1.id, s1.name);
    fprintf(fptr, "%d %s\\n", s2.id, s2.name);

    fclose(fptr);
    printf("Students saved successfully!\\n");
    return 0;
}
    

C Reference

This section serves as a quick reference for keywords, standard libraries, and common functions used in C programming.

C Examples

Practical examples demonstrating key C concepts in real-life scenarios.

#include <stdio.h>

int main() {
    char op;
    double num1, num2;
    printf("Enter operation (+,-,*,/): ");
    scanf("%c", &op);
    printf("Enter two numbers: ");
    scanf("%lf %lf", &num1, &num2);

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

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

struct Account {
    int id;
    double balance;
};

int main() {
    struct Account acc = {1001, 5000.0};
    double deposit, withdraw;
    
    printf("Deposit amount: "); scanf("%lf", &deposit);
    acc.balance += deposit;

    printf("Withdraw amount: "); scanf("%lf", &withdraw);
    if(withdraw <= acc.balance) acc.balance -= withdraw;
    else printf("Insufficient balance\\n");

    printf("Current Balance: %.2lf\\n", acc.balance);
    return 0;
}