C++

C++

Join this Course

Responsible	Administrator
Last Update	09/13/2026
Members	1

Course
Reviews

Section 1: Getting Started

6Lessons ·
- 1: Setting Up a C++ Compiler and Build Tools
  
  Preview
- 2: From C to C++: What's Different
  
  Preview
- 3: Your First C++ Program
  
  Preview
- 4: Compilation Stages: Preprocessing, Compiling, Linking
  
  Preview
- 5: Choosing an IDE for C++ Development
  
  Preview
- 6: Understanding C++ Standards: C++11 through C++23
  
  Preview
Section 2: Core Syntax

16Lessons ·
- 7: Variables, Types, and References
  
  Preview
- 8: Fundamental Types and Their Sizes
  
  Preview
- 9: Type Inference with auto
  
  Preview
- 10: Operators and Expressions
  
  Preview
- 11: Control Flow: If/Else
  
  Preview
- 12: Control Flow: Switch Statements
  
  Preview
- 13: For Loops
  
  Preview
- 14: Range-Based For Loops
  
  Preview
- 15: While and Do-While Loops
  
  Preview
- 16: Functions and Overloading
  
  Preview
- 17: Default Arguments
  
  Preview
- 18: Inline Functions
  
  Preview
- 19: Namespaces
  
  Preview
- 20: Using Directives and Declarations
  
  Preview
- 21: Constants: const and constexpr
  
  Preview
- 22: Practice Exercise: Building a Simple Calculator
  
  Preview
Section 3: Object-Oriented C++

20Lessons ·
- 23: Classes and Objects
  
  Preview
- 24: Constructors and Destructors
  
  Preview
- 25: Constructor Overloading and Delegation
  
  Preview
- 26: Copy Constructors and the Copy Assignment Operator
  
  Preview
- 27: Move Constructors and Move Assignment
  
  Preview
- 28: Inheritance and Access Control
  
  Preview
- 29: Multiple Inheritance
  
  Preview
- 30: Virtual Inheritance and the Diamond Problem
  
  Preview
- 31: Polymorphism and Virtual Functions
  
  Preview
- 32: Pure Virtual Functions and Abstract Classes
  
  Preview
- 33: Virtual Destructors
  
  Preview
- 34: Interfaces via Abstract Base Classes
  
  Preview
- 35: Operator Overloading: Arithmetic Operators
  
  Preview
- 36: Operator Overloading: Stream Operators
  
  Preview
- 37: Operator Overloading: Comparison Operators
  
  Preview
- 38: Operator Overloading: Subscript and Function Call
  
  Preview
- 39: Friend Functions and Classes
  
  Preview
- 40: Static Members
  
  Preview
- 41: The this Pointer
  
  Preview
- 42: Practice Exercise: Building a Class-Based Shape Hierarchy
  
  Preview
Section 4: Memory Management

11Lessons ·
- 43: Stack vs Heap in C++
  
  Preview
- 44: Pointers and References Revisited
  
  Preview
- 45: new and delete
  
  Preview
- 46: Dynamic Arrays with new[]
  
  Preview
- 47: Smart Pointers: unique_ptr
  
  Preview
- 48: Smart Pointers: shared_ptr
  
  Preview
- 49: Smart Pointers: weak_ptr
  
  Preview
- 50: RAII and Resource Management
  
  Preview
- 51: Avoiding Memory Leaks and Dangling Pointers
  
  Preview
- 52: Custom Deleters for Smart Pointers
  
  Preview
- 53: Practice Exercise: Refactoring Raw Pointers to Smart Pointers
  
  Preview
Section 5: Templates and Generic Programming

9Lessons ·
- 54: Function Templates
  
  Preview
- 55: Class Templates
  
  Preview
- 56: Template Specialization
  
  Preview
- 57: Partial Specialization
  
  Preview
- 58: Variadic Templates
  
  Preview
- 59: Template Metaprogramming Basics
  
  Preview
- 60: Concepts and Constraints (C++20)
  
  Preview
- 61: SFINAE Explained
  
  Preview
- 62: Practice Exercise: Building a Generic Stack Class
  
  Preview
Section 6: The Standard Template Library

20Lessons ·
- 63: Vectors: Growth and Performance
  
  Preview
- 64: Deques and Lists
  
  Preview
- 65: Sets and Multisets
  
  Preview
- 66: Maps and Multimaps
  
  Preview
- 67: Unordered Containers and Hashing
  
  Preview
- 68: Iterators Explained
  
  Preview
- 69: Iterator Categories
  
  Preview
- 70: Algorithms Library: sort, find, transform
  
  Preview
- 71: Algorithms Library: accumulate and count_if
  
  Preview
- 72: Custom Comparators and Functors
  
  Preview
- 73: std::string in Depth
  
  Preview
- 74: std::string_view for Efficient Views
  
  Preview
- 75: std::array for Fixed-Size Arrays
  
  Preview
- 76: std::optional for Nullable Values
  
  Preview
- 77: std::variant for Type-Safe Unions
  
  Preview
- 78: std::any for Type-Erased Storage
  
  Preview
- 79: Priority Queues and Heaps in the STL
  
  Preview
- 80: Stacks and Queues via Container Adapters
  
  Preview
- 81: Bitsets for Fixed-Size Bit Manipulation
  
  Preview
- 82: Practice Exercise: Solving Problems with STL Containers
  
  Preview
Section 7: Modern C++ Features

14Lessons ·
- 83: auto and Type Deduction Revisited
  
  Preview
- 84: Lambda Expressions
  
  Preview
- 85: Lambda Captures in Depth
  
  Preview
- 86: Generic Lambdas
  
  Preview
- 87: Move Semantics and Rvalue References
  
  Preview
- 88: Perfect Forwarding
  
  Preview
- 89: Structured Bindings
  
  Preview
- 90: Ranges (C++20)
  
  Preview
- 91: Modules (C++20)
  
  Preview
- 92: Coroutines (C++20)
  
  Preview
- 93: constexpr Functions and Compile-Time Computation
  
  Preview
- 94: if constexpr for Compile-Time Branching
  
  Preview
- 95: Deducing this (C++23)
  
  Preview
- 96: std::expected for Error Handling
  
  Preview
Section 8: Error Handling

8Lessons ·
- 97: Exceptions and Exception Safety
  
  Preview
- 98: The Exception Hierarchy in the Standard Library
  
  Preview
- 99: Custom Exception Hierarchies
  
  Preview
- 100: noexcept and Its Guarantees
  
  Preview
- 101: Error Codes vs Exceptions
  
  Preview
- 102: RAII for Exception Safety
  
  Preview
- 103: The Three Levels of Exception Safety Guarantees
  
  Preview
- 104: Writing Exception-Safe Container Operations
  
  Preview
Section 9: Multithreading

10Lessons ·
- 105: Threads with std::thread
  
  Preview
- 106: Joining and Detaching Threads
  
  Preview
- 107: Mutexes and Locking Strategies
  
  Preview
- 108: Lock Guards and Unique Locks
  
  Preview
- 109: Condition Variables
  
  Preview
- 110: Atomics and Lock-Free Basics
  
  Preview
- 111: Futures, Promises, and Async Tasks
  
  Preview
- 112: Thread Pools
  
  Preview
- 113: Data Races and How to Avoid Them
  
  Preview
- 114: Practice Exercise: Building a Thread-Safe Task Queue
  
  Preview
Section 10: Operator Overloading and Type Conversion

3Lessons ·
- 115: Overloading the Increment and Decrement Operators
  
  Preview
- 116: Conversion Operators and explicit
  
  Preview
- 117: Type Casting: static_cast, dynamic_cast, const_cast, reinterpret_cast
  
  Preview
Section 11: Advanced Topics

8Lessons ·
- 118: The Rule of Three, Five, and Zero
  
  Preview
- 119: CRTP and Compile-Time Polymorphism
  
  Preview
- 120: Custom Allocators
  
  Preview
- 121: Working with the C++ Filesystem Library
  
  Preview
- 122: Type Traits and Compile-Time Introspection
  
  Preview
- 123: PIMPL Idiom for ABI Stability
  
  Preview
- 124: Copy Elision and Return Value Optimization
  
  Preview
- 125: Custom Iterators for User-Defined Containers
  
  Preview
Section 12: Tooling and Build Systems

9Lessons ·
- 126: Build Systems with CMake
  
  Preview
- 127: Managing Dependencies with vcpkg or Conan
  
  Preview
- 128: Static vs Dynamic Libraries
  
  Preview
- 129: Unit Testing with Google Test
  
  Preview
- 130: Unit Testing with Catch2
  
  Preview
- 131: Debugging with GDB
  
  Preview
- 132: Memory Debugging with Valgrind and Sanitizers
  
  Preview
- 133: Static Analysis Tools for C++
  
  Preview
- 134: Practice Exercise: Setting Up a CMake Project with Tests
  
  Preview
Section 13: Design Patterns in C++

9Lessons ·
- 135: The Singleton Pattern in C++
  
  Preview
- 136: The Factory Pattern
  
  Preview
- 137: The Observer Pattern
  
  Preview
- 138: The Strategy Pattern
  
  Preview
- 139: The Command Pattern
  
  Preview
- 140: The Visitor Pattern
  
  Preview
- 141: The Decorator Pattern (Structural)
  
  Preview
- 142: The Composite Pattern
  
  Preview
- 143: Dependency Injection in C++
  
  Preview
Section 14: Interfacing with C and Systems Programming

5Lessons ·
- 144: Calling C Libraries from C++
  
  Preview
- 145: extern C and Linkage
  
  Preview
- 146: Writing C++ Code for Embedded Systems
  
  Preview
- 147: Memory-Mapped I/O and Low-Level Access
  
  Preview
- 148: Working with Bit Fields and Packed Structs
  
  Preview
Section 15: Networking and IPC Basics

3Lessons ·
- 149: Socket Programming in C++
  
  Preview
- 150: Inter-Process Communication Basics
  
  Preview
- 151: Building a Simple TCP Echo Server
  
  Preview
Section 16: Graphics and Game Programming Basics

4Lessons ·
- 152: Setting Up a Basic Rendering Loop
  
  Preview
- 153: Working with a 2D Graphics Library
  
  Preview
- 154: Handling Input and Game State
  
  Preview
- 155: Basic Collision Detection Concepts
  
  Preview
Section 17: The Boost Libraries

3Lessons ·
- 156: Overview of the Boost Ecosystem
  
  Preview
- 157: Boost.Asio for Asynchronous I/O
  
  Preview
- 158: Boost.Optional and Boost.Variant Before Standardization
  
  Preview
Section 18: Data Structures and Algorithms in C++

12Lessons ·
- 159: Implementing a Linked List in C++
  
  Preview
- 160: Implementing a Doubly Linked List in C++
  
  Preview
- 161: Implementing a Binary Search Tree in C++
  
  Preview
- 162: Implementing an AVL Tree in C++
  
  Preview
- 163: Implementing a Graph with Adjacency Lists in C++
  
  Preview
- 164: Graph Traversal: BFS and DFS in C++
  
  Preview
- 165: Implementing a Hash Table in C++
  
  Preview
- 166: Implementing a Trie in C++
  
  Preview
- 167: Implementing a Min-Heap and Max-Heap in C++
  
  Preview
- 168: Dynamic Programming Patterns in C++
  
  Preview
- 169: Greedy Algorithm Patterns in C++
  
  Preview
- 170: Backtracking Patterns in C++
  
  Preview
Section 19: Practical Projects

16Lessons ·
- 171: Building a Command-Line Calculator
  
  Preview
- 172: Implementing a Custom Linked List Container
  
  Preview
- 173: Building a Simple Memory Pool Allocator
  
  Preview
- 174: Building a Basic Multithreaded Task Queue
  
  Preview
- 175: Building a Small Game with a Game Loop
  
  Preview
- 176: Building a Simple JSON Parser
  
  Preview
- 177: Building a Basic HTTP Client from Sockets
  
  Preview
- 178: Implementing a Custom Smart Pointer from Scratch
  
  Preview
- 179: Building a Thread-Safe Producer-Consumer Pipeline
  
  Preview
- 180: Building a Simple Banking System with File Persistence
  
  Preview
- 181: Building a Text-Based Inventory Management System
  
  Preview
- 182: Building a Tic-Tac-Toe Game with a Minimax AI
  
  Preview
- 183: Building a Simple Chess Move Validator
  
  Preview
- 184: Building a Basic Ray Tracer in C++
  
  Preview
- 185: Building a Simple Compiler/Interpreter for a Toy Language
  
  Preview
- 186: Building a Library Management System with File Persistence
  
  Preview
Section 20: More Concurrency Patterns

4Lessons ·
- 187: Parallel Algorithms with the Execution Policy (C++17)
  
  Preview
- 188: Building a Thread Pool from Scratch
  
  Preview
- 189: Lock-Free Data Structures Basics
  
  Preview
- 190: Async Programming with std::async
  
  Preview
Section 21: More OOP and Design Practice

5Lessons ·
- 191: Practice Exercise: Building a Shape Hierarchy with Area Calculations
  
  Preview
- 192: Practice Exercise: Modeling an Employee Management System
  
  Preview
- 193: Practice Exercise: Building a Simple Plugin Architecture with Abstract Interfaces
  
  Preview
- 194: The Adapter Pattern in Practice
  
  Preview
- 195: The Facade Pattern in Practice
  
  Preview
Section 22: File I/O and Streams

5Lessons ·
- 196: Reading and Writing Files with fstream
  
  Preview
- 197: Stream Manipulators for Formatted Output
  
  Preview
- 198: String Streams with stringstream
  
  Preview
- 199: Binary File I/O in C++
  
  Preview
- 200: Error Handling for File Streams
  
  Preview
Section 23: More Standard Library

6Lessons ·
- 201: Working with Dates and Times: chrono
  
  Preview
- 202: Random Number Generation with <random>
  
  Preview
- 203: Regular Expressions with <regex>
  
  Preview
- 204: The <algorithm> Header: More Algorithms
  
  Preview
- 205: The <numeric> Header: accumulate, inner_product
  
  Preview
- 206: Working with Multidimensional Data: valarray
  
  Preview
Section 24: Practice Exercises

5Lessons ·
- 207: Practice Exercise: Building a Student Grading System
  
  Preview
- 208: Practice Exercise: Building a Simple Matrix Class with Operator Overloading
  
  Preview
- 209: Practice Exercise: Building a Custom String Class
  
  Preview
- 210: Practice Exercise: Implementing a Simple Observer-Based Event System
  
  Preview
- 211: Practice Exercise: Building a Template-Based Generic Container
  
  Preview
Section 25: Interview and Algorithm Practice

9Lessons ·
- 212: Implementing Sorting Algorithms in C++
  
  Preview
- 213: Implementing Data Structures from Scratch: Trees and Graphs
  
  Preview
- 214: Solving Dynamic Programming Problems in C++
  
  Preview
- 215: Common C++ Interview Questions on Memory and Objects
  
  Preview
- 216: Common C++ Interview Questions on Templates
  
  Preview
- 217: Whiteboard Practice: Detecting a Cycle in a Linked List
  
  Preview
- 218: Whiteboard Practice: Reversing a Linked List
  
  Preview
- 219: Whiteboard Practice: Two-Pointer and Sliding Window Problems
  
  Preview
- 220: Mock Coding Interview Walkthrough in C++
  
  Preview
Section 26: Compiler and Language Internals

6Lessons ·
- 221: How Templates Are Instantiated at Compile Time
  
  Preview
- 222: Understanding Name Mangling
  
  Preview
- 223: One Definition Rule Explained
  
  Preview
- 224: Compiler Optimization Flags and Their Effects
  
  Preview
- 225: Understanding vtables and Dynamic Dispatch Internals
  
  Preview
- 226: Undefined Behavior: Common Pitfalls
  
  Preview
Section 27: GUI and Application Frameworks Overview

3Lessons ·
- 227: Overview of Qt for Cross-Platform GUI Development
  
  Preview
- 228: Building a Simple Qt Application
  
  Preview
- 229: Overview of wxWidgets and Dear ImGui
  
  Preview
Section 28: Testing and Quality Practices

4Lessons ·
- 230: Test-Driven Development in C++
  
  Preview
- 231: Mocking Dependencies with Google Mock
  
  Preview
- 232: Continuous Integration for C++ Projects
  
  Preview
- 233: Code Coverage Tools for C++
  
  Preview
Section 29: Numerics Library

5Lessons ·
- 234: The <numeric> Header: accumulate, inner_product, adjacent_difference
  
  Preview
- 235: The <random> Header: Distributions and Engines
  
  Preview
- 236: The <complex> Header for Complex Numbers
  
  Preview
- 237: The <ratio> Header for Compile-Time Rational Arithmetic
  
  Preview
- 238: Numeric Limits with <limits>
  
  Preview
Section 30: Concepts Library (C++20)

3Lessons ·
- 239: Standard Library Concepts: same_as, convertible_to, integral
  
  Preview
- 240: Writing Custom Concepts
  
  Preview
- 241: Concepts vs SFINAE for Constraint Checking
  
  Preview
Section 31: Ranges Library (C++20) In Depth

3Lessons ·
- 242: Range Views: filter, transform, take
  
  Preview
- 243: Range Adaptors and Composability
  
  Preview
- 244: Range Algorithms vs Classic Algorithms
  
  Preview
Section 32: More Utility Library

6Lessons ·
- 245: std::tuple and std::pair In Depth
  
  Preview
- 246: std::function and Type Erasure
  
  Preview
- 247: std::reference_wrapper
  
  Preview
- 248: Compile-Time Constants with std::integral_constant
  
  Preview
- 249: std::chrono for Time and Durations
  
  Preview
- 250: std::filesystem Path Manipulation In Depth
  
  Preview