100-Hour Comprehensive C Programming Workshop
Beginner to Advanced | Complete Theory + Practical Mastery
Program Objective
This workshop is designed to equip participants with deep and practical
knowledge of the C programming language — from fundamentals to
advanced system-level programming. It emphasizes writing efficient,
modular, and maintainable C code and mastering both theoretical and hands-
on concepts.
By the end of this workshop, participants will be able to:
● Write robust C programs from scratch.
● Understand and apply advanced memory management and data
structures.
● Build real-world systems using procedural paradigms in C.
● Debug and optimize C code with professional-grade tools.
● Transition smoothly into systems, embedded, and OS-level
programming.
Workshop Overview Table
Module Topic Duration (Hours)
Module 1 Programming Foundations & C Overview 5
Module 2 Tokens, Variables, and Data Types 6
Module 3 Input/Output and Operators 4
Module 4 Control Flow Statements 8
Module 5 Functions and Modular Programming 8
Module 6 Arrays and Strings 10
Module 7 Pointers and Memory Management 12
Module 8 Structures, Unions, and Enums 10
Module 9 File Handling 8
Module 10 Advanced C Concepts 10
Module 11 Data Structures in C 14
Module 12 Debugging, Testing, and Optimization 5
Module 13 Capstone Projects 10
Total 100 Hours
Module 1: Introduction to C & Programming Basics (6 Hours)
Objective: Build foundational understanding of programming concepts and the C language.
● What is Programming? (Overview, programming paradigms)
● Evolution of Programming Languages.
● Why C? (History, features, relevance today)
● History, Features & Applications of C.
● C Language Characteristics (Procedural, Mid-level, Portable)
● C vs C++, Java, Python
● Introduction to GCC, TCC, and IDEs (Code::Blocks, VS Code)
● Compilation Process: Source code to executable (Preprocessing → Compilation →
Linking).
● C Program Structure: main(), headers, statements, comments, semicolons.
● First Program Walkthrough: Hello, World!
Hands-On:
● Write and compile your first C program
● Identify syntax components in code
● Add comments and output custom messages
Module 2: C Development Environment (4 Hours)
Objective: Set up and use tools to write, compile, and debug C programs effectively.
● Installation: GCC, MinGW, or IDEs (Code::Blocks, VS Code)
● Using Command-Line Tools: gcc, gdb, terminal basics
● IDE Basics: Project structure, build/run, debugging tools
● Input/Output Basics: printf(), scanf(), format specifiers
● C Tokens: Keywords, Identifiers, Constants, Strings, Symbols
Hands-On:
● Install and configure C environment
● Write programs using both IDE and terminal
● Use scanf() to read input and display output
Module 3: Variables, Data Types & Operators (8 Hours)
Objective: Understand C's fundamental building blocks—data, types, and operations.
● Variables: Declaration, initialization, naming rules.
● Data Types
o
Primary: int, float, char, double
o
Derived: array, pointer, structure, union
o
User-defined types
● Constants: const, #define, literals
● Type Modifiers: short, long, signed, unsigned
● Storage Classes: auto, register, static, extern
● Type Conversion & Type Casting
● Operators:
o Arithmetic: +, -, *, /, %
o Relational: ==, !=, >, <, >=, <=
o Logical: &&, ||, !
o Assignment: =, +=, -=, etc.
o Increment/Decrement: ++, --
o Bitwise Operators (Intro)
o Operator Precedence & Associativity
Hands-On:
● Area, perimeter, and basic calculators
● Variable exercises, data type conversions, memory size checks
● Use all operator types in simple expressions
● Experiment with type conversions and data overflow
Module 4: Control Flow Statements (8 Hours)
Objective: Master conditional logic and loops to control program execution.
A. Conditional Statements (4 Hours)
● if, if-else, else-if: Basic decisions, nested conditions, grading, login checks.
● switch-case: Menu-driven programs, calculators, day-of-week display.
● Ternary Operator: Simple one-line conditions.
● Best Practices: Indentation, avoiding deep nesting.
Hands-On:
● Voting checker, menu calculator, grade evaluator.
B. Loops (3 Hours)
● for Loop: Fixed iterations, patterns, tables.
● while Loop: Condition-based, sentinel input.
● do-while Loop: Post-check loops for menus/retries.
● Nested Loops: Star patterns, matrix operations.
Hands-On:
● Factorial, number series, pyramid printing.
C. Loop Control (1 Hour)
● break: Exit loop early.
● continue: Skip current iteration.
● goto: Jump (academic use only).
Hands-On:
● Skip numbers, search with early exit.
Module 5: Functions & Modular Programming (8 Hours)
Objective: Build modular, reusable, and maintainable C programs using functions.
● Function Syntax: Declaration, definition, invocation
● Function Types: With/without arguments and return types
● Call by Value vs Reference
● Recursion: Concept, stack behavior, factorial, Fibonacci, GCD
● Variable Scope & Lifetime: Local, global, static, register
● Function Prototypes: Importance, placement in code
● Header Files & Modularization: .h and .c files, compiling multi-file projects
● Designing Modular Code: Logical decomposition of large codebases
Hands-On:
● Recursive factorial, Fibonacci, GCD calculator
● Scientific calculator using multiple functions
● Temperature converter using reusable function modules
● Recursive string reverse and palindrome checker
Module 6: Arrays & Strings (10 Hours)
Objective: Store, manage, and manipulate sequential data using arrays and strings.
● 1D Arrays: Initialization, traversal, insertion, deletion, sorting, searching
● 2D Arrays: Matrix representation, arithmetic operations, memory layout
● String Basics: Declaration, input/output, character arrays vs pointers
● Manual String Operations: Reversal, case conversion, search
● String Library Functions: strlen(), strcpy(), strcat(), strcmp(), strchr(), etc.
● Strings & Memory: Null termination, buffer overflow risks
Hands-On:
● Bubble, insertion, and selection sort
● Binary and linear search implementations
● Matrix operations: addition, transpose, multiplication
● Palindrome checker (string & number)
● Anagram validator
Module 7: Pointers & Memory Management (12 Hours)
Objective: Understand low-level memory handling using pointers and dynamic allocation.
● Pointers Basics: Declaration, dereferencing, address-of operator
● Pointer Arithmetic: Traversal through arrays
● Pointer to Pointer
● Pointers with Arrays and Strings
● Pointers to Functions & Structures
● Dynamic Memory: malloc(), calloc(), realloc(), free()
● Pointer Pitfalls: Dangling pointers, memory leaks, segmentation faults
Hands-On:
● Swapping values using pointers
● Pointer-based array manipulations
● Callback mechanism using function pointers
● Custom implementation of strcpy, strlen using pointers
Module 8: Structures, Unions & Enums (10 Hours)
Objective: Represent real-world entities using user-defined types.
● Structures: Declaration, initialization, arrays of structures, nested structures
● Passing Structures to Functions: By value and by reference
● Pointers to Structures
● Unions: Memory-efficient grouping, structure vs union
● Enums: Declaring symbolic constants
● Typedefs: Simplify type declarations
Hands-On:
● Student database system with structure arrays
● Union vs structure memory benchmarking
● Hospital management (basic patient details via structures)
Module 9: File Handling (8 Hours)
Objective: Handle file-based input/output for data persistence.
● File Operations: fopen(), fclose(), fprintf(), fscanf(), fgets(), fputs()
● Text vs Binary File Handling
● File Modes: "r", "w", "a", "rb", "wb"
● File Pointers & Positioning: fseek(), ftell(), rewind()
● End-of-File Detection: feof(), error handling
Hands-On:
● Contact manager: add, search, delete entries
● Word counter in a text file
● Merge two files into one
● CSV parser and record extractor
Module 10: Advanced C Concepts (10 Hours)
Objective: Gain control over low-level features and optimize program behavior.
● Bitwise Operators: &, |, ^, ~, <<, >>
● Command-Line Arguments: argc, argv[]
● Type Qualifiers: const, volatile, restrict
● Preprocessor Directives: #define, #undef, #include, #ifdef, macros
● Memory Layout of a Program: Code, data, heap, stack segments
● Linking: Static vs dynamic, use of object files
● Inline Assembly (Intro): GCC inline syntax, register access
Hands-On:
● Static/dynamic memory benchmarking
● Preprocessor-driven debugging flags
● Custom header file with utility macros
Module 11: Data Structures in C (14 Hours)
Objective: Implement foundational data structures using raw pointers and structures.
● Linked Lists: Singly, doubly, circular (with operations)
● Stacks: Array-based and linked-list based
● Queues: Standard and circular
● Trees: Binary trees, BST operations, traversals
● Graphs (Intro): Adjacency matrix and list
● Hash Tables (Basic): Hashing, collisions
Hands-On:
● Queue simulator (printer queue, customer service)
● Simple graph traversal (DFS, BFS intro)
● Data structure library (custom .h and .c files)
Module 12: Debugging, Testing & Optimization (5 Hours)
Objective: Build robust, clean, and efficient programs.
● Error Types: Compile-time, runtime, logic
● Debugging Tools: GDB usage, breakpoints, watches
● Assertions & Testing: assert(), test case design
● Optimization Techniques: Time/memory trade-offs, code simplification
● Clean Code: Readability, modularity, documentation
● Version Control (Git Basics): Init, commit, diff, log
Hands-On Projects
● Debug and fix broken programs
● Use Git to version a student project
● Refactor a poorly written codebase (clean coding exercise)
Module 13: Capstone Projects (10 Hours)
Objective: Apply cumulative knowledge to build a real-world, functional application.
Project Options
● Contact Manager (File + Structures + Menus)
● File Compressor (Run-Length Encoding logic)
● Mini Shell (Basic command execution with arguments)
● Console Games (Tic Tac Toe, Snake with 2D arrays)
● Report Generator (File parsing and formatted output)
● File Encryptor (Bitwise + file handling)
Expected Deliverables
● Fully working code
● Proper documentation (README, sample input/output)
● GitHub repository
● Final demonstration and code walkthrough
