C and C++ Course

Lesson 1 • Control Flow and Loops

Teaches if/else, switch, for, while, and do-while constructs. Enables learners to write programs with branching and repetition logic.

Lesson 2 • Variables, Data Types, and Operators

Covers primitive types, variable declaration, and arithmetic/logical operators. Provides the building blocks for all C expressions.

Lesson 3 • Functions and Scope

Defines function declaration, definition, parameters, and return values. Introduces local vs. global scope and the call stack.

Lesson 4 • Setting Up the Development Environment

Install and configure a C compiler, editor, and build tools. Establishes the toolchain every subsequent chapter depends on.

Lesson 1 • Arrays, Strings, and Pointers

Explores the relationship between arrays, C strings, and pointer arithmetic. Reinforces pointer concepts through practical string manipulation.

Lesson 2 • Pointers and Functions

Covers pass-by-pointer, function pointers, and returning pointers. Extends function knowledge from Chapter 1 to enable in-place modification.

Lesson 3 • Pointer Fundamentals

Introduces address-of and dereference operators, pointer types, and NULL. Builds the conceptual model required for all advanced memory topics.

Lesson 4 • Dynamic Memory Allocation

Teaches malloc, calloc, realloc, and free for heap management. Learners learn to allocate and release memory at runtime.

Lesson 1 • Unions and Enumerations

Covers union memory sharing and enum-based named constants. Provides tools for memory-efficient type design and readable code.

Lesson 2 • Linked Lists and Dynamic Structures

Builds singly and doubly linked lists using structs and pointers. Applies dynamic allocation from Chapter 2 to real data structure design.

Lesson 3 • Binary File I/O

Teaches fread, fwrite, and fseek for binary data persistence. Enables efficient storage and retrieval of struct data.

Lesson 4 • Structs and User-Defined Types

Defines struct syntax, member access, and nested structs. Enables grouping of related data into cohesive, reusable types.

Lesson 1 • Preprocessor Directives

Covers #define, #include, #ifdef, and #pragma. Shows how the preprocessor transforms source before compilation.

Lesson 2 • Debugging and Profiling Tools

Covers GDB for step-through debugging and gprof for profiling. Builds diagnostic skills applicable to all future C and C++ work.

Lesson 3 • Makefiles and Build Automation

Introduces Makefile syntax, targets, dependencies, and variables. Automates compilation of multi-file projects efficiently.

Lesson 1 • Operator Overloading

Teaches overloading arithmetic, comparison, and stream operators. Enables intuitive syntax for user-defined types.

Lesson 2 • Constructors and Object Lifecycle

Explores copy constructors, move semantics, and destructor behavior. Prepares learners for resource-safe class design.

Lesson 3 • C++ Syntax Differences from C

Highlights namespaces, references, bool type, and inline functions. Smooths the transition by mapping familiar C constructs to C++ equivalents.

Lesson 4 • Classes and Objects

Defines class syntax, access specifiers, and member functions. Introduces the object as the central unit of C++ program design.

Lesson 1 • Virtual Functions and Polymorphism

Introduces virtual keyword, vtable mechanics, and dynamic dispatch. Enables writing code that operates on base-class pointers polymorphically.

Lesson 2 • SOLID Principles in C++

Applies single responsibility, open-closed, and Liskov substitution principles. Connects OOP mechanics to professional software design standards.

Lesson 3 • Abstract Classes and Interfaces

Defines abstract classes via pure virtual functions and interface patterns. Teaches design contracts that derived classes must fulfill.

Lesson 4 • Inheritance Fundamentals

Covers base and derived class syntax, access inheritance, and constructor chaining. Establishes the is-a relationship central to OOP design.

Lesson 1 • STL Algorithms and Iterators

Applies sort, find, transform, and accumulate with iterator ranges. Replaces manual loops with expressive, tested library algorithms.

Lesson 2 • Smart Pointers and RAII

Introduces unique_ptr, shared_ptr, and weak_ptr for automatic memory management. Applies RAII to eliminate manual delete calls.

Lesson 3 • Function and Class Templates

Covers template syntax, type parameters, and template specialization. Enables writing type-independent, reusable functions and classes.

Lesson 4 • STL Associative Containers

Covers map, set, unordered_map, and unordered_set with complexity guarantees. Enables fast lookup and unique-element management.

Lesson 1 • C++20 Features Overview

Surveys concepts, ranges, coroutines, and modules introduced in C++20. Positions learners to adopt the latest standard in professional projects.

Lesson 2 • Compile-Time Programming

Covers constexpr, if constexpr, and variadic templates for compile-time logic. Reduces runtime overhead through static computation.

Lesson 3 • Move Semantics and Perfect Forwarding

Deepens understanding of rvalue references, std::move, and std::forward. Enables zero-cost resource transfer in performance-critical code.

Lesson 4 • Lambda Expressions and Functional Patterns

Covers lambda syntax, capture lists, and use with STL algorithms. Enables concise, inline function objects for modern C++ idioms.