C/C++ Course

Lesson 1 • Variables, Types, and Literals

Introduces primitive data types, variable declaration, and literal values. Mastery here enables correct data representation throughout the course.

Lesson 2 • Input and Output Fundamentals

Teaches console I/O using printf/scanf in C and cin/cout in C++. Enables interactive programs required in every hands-on exercise.

Lesson 3 • Operators and Expressions

Covers arithmetic, relational, logical, and bitwise operators with precedence rules. Builds the expression-writing skill needed for all control flow and algorithms.

Lesson 4 • Core Syntax and Program Structure

Covers tokens, statements, blocks, and the anatomy of a C/C++ source file. Connects directly to writing any valid program in later chapters.

Lesson 1 • Function Declaration and Definition

Introduces function prototypes, definitions, and call mechanics in C/C++. Establishes modular design principles used throughout the course.

Lesson 2 • Scope, Lifetime, and Storage Classes

Explains local, global, and static variables and their lifetimes. Prevents common bugs related to uninitialised or misscoped variables.

Lesson 3 • Recursion Fundamentals

Covers recursive function design, base cases, and stack behaviour. Prepares students for recursive algorithms and data structures in later chapters.

Lesson 4 • Conditional Statements

Covers if, else-if, and switch constructs for decision-making. Directly enables logic-driven programs built upon in every subsequent chapter.

Lesson 1 • C-Style Strings and String Functions

Teaches null-terminated character arrays and standard string library functions. Provides the C-string foundation needed before C++ std::string is introduced.

Lesson 2 • Dynamic Memory Allocation

Teaches malloc/free in C and new/delete in C++ for heap management. Lays the groundwork for dynamic data structures covered in the next chapter.

Lesson 3 • One-Dimensional and Multi-Dimensional Arrays

Covers array declaration, initialisation, and element access patterns. Arrays underpin nearly every data structure introduced later in the course.

Lesson 4 • Pointers and Functions

Covers passing pointers to functions and returning pointers safely. Enables efficient data manipulation without unnecessary copying.

Lesson 1 • Enumerations and Type Aliases

Covers C enums, C++ enum class, and typedef/using declarations. Improves code clarity and type safety in all subsequent projects.

Lesson 2 • Bit Fields and Packed Data

Introduces bit-field struct members for compact data representation. Relevant to protocol parsing and hardware register mapping in advanced topics.

Lesson 3 • Pointers to Structures

Teaches pointer-based struct access and dynamic struct allocation. Enables linked data structures built in the algorithms chapter.

Lesson 4 • Unions and Memory Sharing

Explains union semantics, overlapping storage, and valid use cases. Provides low-level memory insight relevant to embedded and systems programming.

Lesson 1 • Polymorphism and Virtual Functions

Introduces virtual functions, pure virtual functions, and abstract classes. Enables runtime dispatch patterns central to extensible software design.

Lesson 2 • Inheritance and Class Hierarchies

Covers single and multiple inheritance, base class access, and constructor chaining. Builds the hierarchy design skills needed for polymorphism.

Lesson 3 • Encapsulation and Design Principles

Applies SOLID principles and encapsulation strategies to class design. Prepares students to write maintainable, testable C++ code in advanced chapters.

Lesson 4 • Operator Overloading

Teaches overloading arithmetic, comparison, and stream operators for custom types. Enables intuitive syntax for user-defined classes used in later projects.

Lesson 1 • STL Algorithms

Covers sort, find, transform, accumulate, and other standard algorithms. Applying STL algorithms replaces error-prone manual loops in production code.

Lesson 2 • Function and Class Templates

Covers template syntax, type parameters, and template instantiation. Generic functions and classes reduce code duplication across all future projects.

Lesson 3 • STL Containers

Introduces vector, list, deque, map, set, and unordered variants. Choosing the right container is critical for performance in algorithm design.

Lesson 4 • Lambda Expressions and Functors

Introduces lambda syntax, captures, and functor objects for use with STL. Enables concise, expressive algorithm customisation in modern C++.

Lesson 1 • Exception Handling and Safety

Covers try/catch/throw, exception hierarchies, and exception-safety guarantees. Robust error handling prevents resource leaks under exceptional conditions.

Lesson 2 • RAII and Resource Ownership

Explains the RAII idiom and how constructors/destructors enforce resource safety. RAII is the foundation of all safe resource management in modern C++.

Lesson 3 • Smart Pointers in Depth

Covers unique_ptr, shared_ptr, and weak_ptr semantics and usage patterns. Smart pointers eliminate manual delete calls and prevent ownership errors.

Lesson 4 • Copy and Move Semantics

Teaches copy constructors, copy assignment, move constructors, and move assignment. The Rule of Five governs correct resource-owning class design.

Lesson 1 • Multithreading with std::thread

Teaches thread creation, joining, and detaching using the C++11 thread library. Concurrency fundamentals enable parallel program design in this chapter.

Lesson 2 • Process and System Interfaces

Introduces process creation, environment variables, and system calls. Provides the OS-level context needed for writing systems-level C programs.

Lesson 3 • Networking and Socket Basics

Introduces BSD socket API for TCP/UDP communication in C/C++. Networking skills extend C/C++ applications to distributed and client-server contexts.

Lesson 4 • Synchronisation and Data Races

Covers mutexes, condition variables, and atomic operations to prevent data races. Safe synchronisation is mandatory for correct concurrent programs.