Chapter 1: Introduction to C++
- Lesson 1: What is C++?
- Lesson 2: History of C++
- Lesson 3: C++ Applications
- Lesson 4: C++ Environment Setup
- Lesson 5: Writing Your First C++ Program
- Lesson 6: Introduction to C++ Syntax
- Lesson 7: Basic C++ Compiler and IDE Setup
Chapter 2: Variables and Data Types
- Lesson 1: What are Variables?
- Lesson 2: Declaring Variables in C++
- Lesson 3: Reserved Keywords
- Lesson 4: Basic Data Types: int, float, char, etc.
- Lesson 5: Modifiers: signed, unsigned, long, short
- Lesson 6: Declaring Constants (const and constexpr)
- Lesson 7: Type Deduction with auto keyword
- Lesson 8: The val Keyword in Recent C++ Versions
Chapter 3: Operators in C++
- Lesson 1: Arithmetic Operators
- Lesson 2: Relational Operators
- Lesson 3: Logical Operators
- Lesson 4: Bitwise Operators
- Lesson 5: Assignment Operators
- Lesson 6: Increment and Decrement Operators
- Lesson 7: Conditional (Ternary) Operator
- Lesson 8: Type-Casting Operators
Chapter 4: Control Structures
- Lesson 1: Introduction to Control Flow
- Lesson 2: if, else, and else-if Statements
- Lesson 3: switch-case Statement
- Lesson 4: Loops: for, while, and do-while
- Lesson 5: Break and Continue Statements
- Lesson 6: goto Statement (Discouraged)
- Lesson 7: C++14 and Later: Range-based for Loops
- Lesson 8: Foreach Loop (C++11 and later)
Chapter 5: Functions in C++
- Lesson 1: What is a Function?
- Lesson 2: Function Declaration, Definition, and Call
- Lesson 3: Function Parameters: Pass-by-value vs Pass-by-reference
- Lesson 4: Function Overloading
- Lesson 5: Default Arguments in Functions
- Lesson 6: Inline Functions
- Lesson 7: Lambda Functions (C++11 and later)
- Lesson 8: Function Templates
- Lesson 9: Recursive Functions
Chapter 6: Arrays and Strings
- Lesson 1: Declaring Arrays
- Lesson 2: Array Initialization
- Lesson 3: Multidimensional Arrays
- Lesson 4: Arrays vs Pointers
- Lesson 5: Passing Arrays to Functions
- Lesson 6: Returning Arrays from Functions
- Lesson 7: Pointer to an Array
- Lesson 8: String Handling in C++
- Lesson 9: C-strings vs C++ String Class
- Lesson 10: Modern C++: std::string Class
- Lesson 11: String Manipulation with Standard Library Functions
Chapter 7: Structure & Union in C++
- Lesson 1: What are Structure?
- Lesson 2: What are Unions?
- Lesson 3: Structure Declaration and Initialization
- Lesson 4: Union Declaration and Initialization
- Lesson 5: Unions vs Structures
- Lesson 6: Practical Applications of Unions and Structures
Chapter 8: Pointers and References
- Lesson 1: Introduction to Pointers
- Lesson 2: Pointer Arithmetic
- Lesson 3: Pointers and Arrays
- Lesson 4: Wild Pointers and Null Pointers
- Lesson 5: Dynamic Memory Allocation: new and delete
- Lesson 6: Dereferencing Pointers
- Lesson 7: Modifying Pointers
- Lesson 8: Pointers to Functions
- Lesson 9: References vs Pointers
- Lesson 10: Smart Pointers (C++11 and later)
Chapter 9: Object-Oriented Programming (OOP) Concepts
- Lesson 1: Introduction to OOP
- Lesson 2: Classes and Objects
- Lesson 3: Constructor and Destructor
- Lesson 4: Member Functions and Data Members
- Lesson 5: Access Specifiers: public, private, protected
- Lesson 6: Static Members and Functions
- Lesson 7: Friend Functions and Classes
Chapter 10: Inheritance in C++
- Lesson 1: What is Inheritance?
- Lesson 2: Base and Derived Classes
- Lesson 3: Constructor and Destructor in Inheritance
- Lesson 4: Single Inheritance
- Lesson 5: Multiple Inheritance
- Lesson 6: Virtual Inheritance
- Lesson 7: Accessing Base Class Members
Chapter 11: Polymorphism in C++
- Lesson 1: What is Polymorphism?
- Lesson 2: Function Overriding
- Lesson 3: Virtual Functions
- Lesson 4: Pure Virtual Functions and Abstract Classes
- Lesson 5: Runtime Polymorphism (Dynamic Binding)
- Lesson 6: Operator Overloading
Chapter 12: Encapsulation in C++
- Lesson 1: What is Encapsulation?
- Lesson 2: Accessor and Mutator Functions
- Lesson 3: Data Hiding
- Lesson 4: Getter and Setter Methods
- Lesson 5: Example of Encapsulation in Real-World Systems
Chapter 13: Enumerations and Enum Classes in C++
- Lesson 1: Introduction to Enumerations
- Lesson 2: Declaring and Defining an Enumeration
- Lesson 3: Default Values and Assigning Values to Enumerators
- Lesson 4: Scoped Enumerations (Enum Class)
- Lesson 5: Strong Typing with enum class
- Lesson 6: Scoped Namespaces in enum class
- Lesson 7: Enumerator Namespaces and Aliases
- Lesson 8: Iterating Over Enum Values
- Lesson 9: Enum Flags and Bitwise Operations
- Lesson 10: Enum with std::map or std::unordered_map
- Lesson 11: Enum with Switch-Case Statements
- Lesson 12: Use Cases for Enumerations and enum class
- Lesson 13: Best Practices for Enumerations and Enum Classes
Chapter 14: C++ Templates
- Lesson 1: Introduction to Templates
- Lesson 2: Function Templates
- Lesson 3: Class Templates
- Lesson 4: Template Specialization
- Lesson 5: Variadic Templates (C++11 and later)
- Lesson 6: Template Metaprogramming
Chapter 15: Exception Handling in C++
- Lesson 1: Introduction to Exceptions
- Lesson 2: try, catch, and throw Keywords
- Lesson 3: Exception Hierarchy and Inheritance
- Lesson 4: Custom Exception Classes
- Lesson 5: Exception Safety
- Lesson 6: noexcept Specifier
- Lesson 7: Modern Exception Handling (C++11 and beyond)
Chapter 1: Standard Template Library (STL) Basics
- Lesson 1: Introduction to STL
- Lesson 2: Overview of STL Components
- Lesson 3: Containers: vector, list, map, set, etc.
- Lesson 4: Iterators in STL
- Lesson 5: STL Algorithms
- Lesson 6: Allocators in STL
Chapter 2: Date and Time in C++
- Lesson 1: Introduction to Date and Time in C++
- Lesson 2: The 'chrono' Library: Basics
- Lesson 3: Working with Time Durations
- Lesson 4: Getting the Current Date and Time
- Lesson 5: Time Zones and Local Time
- Lesson 6: Formatting Date and Time (C++20 and later)
- Lesson 7: Converting Between Different Time Points
- Lesson 8: Time Calculations and Differences
- Lesson 9: Date and Time Manipulation in C++98/03 (Without 'chrono')
- Lesson 10: Date and Time Libraries in Modern C++
- Lesson 11: Time Performance and Optimization
- Lesson 12: Best Practices for Using Date and Time in C++
Chapter 3: C++11 and Later Features
- Lesson 1: Overview of C++11 Features
- Lesson 2: nullptr
- Lesson 3: Automatic Type Deduction with auto keyword
- Lesson 4: Range-based for Loop
- Lesson 5: Lambda Expressions
- Lesson 6: Smart Pointers (unique_ptr, shared_ptr, weak_ptr)
- Lesson 7: rvalue References and Move Semantics
- Lesson 8: Threading and Concurrency
Chapter 4: Modern C++ Features
(C++14, C++17, C++20, C++23)
(C++14, C++17, C++20, C++23)
- Lesson 1: C++14 Features
- Lesson 2: C++17 Features
- Lesson 3: C++20 Features
- Lesson 4: C++23 Features
- Lesson 5: Concepts (C++20)
- Lesson 6: Ranges Library (C++20)
- Lesson 7: Coroutines (C++20)
- Lesson 8: Modules (C++20 and beyond)
Chapter 5: Advanced C++ Concepts
- Lesson 1: Move Semantics and Move Constructors
- Lesson 2: Copy Elision and Return Value Optimization (RVO)
- Lesson 3: Memory Management in C++
- Lesson 4: Memory Leaks and Preventing Them
- Lesson 5: RAII (Resource Acquisition Is Initialization)
- Lesson 6: C++ Memory Model and Atomics
Chapter 6: Multithreading and Concurrency in C++
- Lesson 1: Introduction to Multithreading
- Lesson 2: Thread Library in C++11
- Lesson 3: std::thread and Thread Creation
- Lesson 4: Synchronization: Mutexes, Locks, and Condition Variables
- Lesson 5: Atomic Operations
- Lesson 6: Parallel Algorithms (C++17 and beyond)
Chapter 7: File I/O in C++
- Lesson 1: File Handling Basics
- Lesson 2: Reading from and Writing to Files
- Lesson 3: Stream Classes and Objects
- Lesson 4: Binary Files
- Lesson 5: Error Handling in File I/O
- Lesson 6: File Pointers and Seek
Chapter 8: C++ and Networking
- Lesson 1: Introduction to Networking in C++
- Lesson 2: Using Sockets in C++
- Lesson 3: TCP/UDP Communication
- Lesson 4: Multithreading in Networked Programs
Chapter 9: C++ Design Patterns
- Lesson 1: What are Design Patterns?
- Lesson 2: Creational Patterns: Singleton, Factory Method, Abstract Factory, Builder, Prototype
- Lesson 3: Structural Patterns: Adapter, Bridge, Composite, Decorator, Facade, Flyweight, Proxy
- Lesson 4: Behavioral Patterns: Chain of Responsibility, Command, Interpreter, Iterator, Mediator, Memento, Observer, State, Strategy, Template Method, Visitor
Chapter 10: Signal Handling
- Lesson 1: Introduction to Signals in C++
- Lesson 2: Signal Types and Common Signals
- Lesson 3: Signal Handlers and signal() Function
- Lesson 4: Signal Masking and Blocking Signals
- Lesson 5: Handling Signals Safely
- Lesson 6: C++17 and Later: std::signal and std::raise
Chapter 11: The C++ Preprocessor
- Lesson 1: Introduction to Preprocessor Directives
- Lesson 2: #define and #undef Directives
- Lesson 3: Conditional Compilation: #if, #ifdef, #ifndef, etc.
- Lesson 4: File Inclusion: #include
- Lesson 5: Macro Functions
- Lesson 6: Preprocessor Tokens and Macro Expansion
- Lesson 7: Inline Functions vs Macros
- Lesson 8: #pragma Directive
Chapter 12: Creating a C++ Library (Part 1)
- Lesson 1: Introduction to C++ Libraries
- Lesson 2: Static vs Dynamic Libraries
- Lesson 3: Structuring Library Code
- Lesson 4: Header Files and Source Files
- Lesson 5: Compiling and Linking a Static Library
Chapter 13: Creating a C++ Library (Part 2)
- Lesson 1: Creating Dynamic Libraries (Shared Libraries)
- Lesson 2: Using dlopen() and dlsym()
- Lesson 3: Handling Library Dependencies
- Lesson 4: Packaging and Distributing C++ Libraries
- Lesson 5: Example: Writing, Compiling, and Using a Library
Chapter 14: C++ Debugging and Testing
- Lesson 1: Introduction to Debugging Techniques
- Lesson 2: Using GDB for Debugging
- Lesson 3: Unit Testing in C++
- Lesson 4: Test-Driven Development (TDD)
- Lesson 5: Using Catch2 and Google Test