first working version
This commit is contained in:
howard
717
learning_plans/cpp/01_KNOWLEDGE_GRAPH.md
Normal file
717
learning_plans/cpp/01_KNOWLEDGE_GRAPH.md
Normal file
@@ -0,0 +1,717 @@
|
||||
# C++ Knowledge Graph - Complete Dependency Map
|
||||
|
||||
## 🌳 Knowledge Tree Structure
|
||||
|
||||
This document maps all C++ concepts with their dependencies, prerequisites, and optimal learning order.
|
||||
|
||||
---
|
||||
|
||||
## Level 1: Foundation Nodes (No Prerequisites)
|
||||
|
||||
### 1.1 Development Environment
|
||||
```
|
||||
┌──────────────────────────────┐
|
||||
│ Compiler Installation │
|
||||
│ - GCC/G++ (Linux, MinGW) │
|
||||
│ - Clang/LLVM (Cross-platform)│
|
||||
│ - MSVC (Windows) │
|
||||
│ - Compiler flags & options │
|
||||
└──────────────────────────────┘
|
||||
│
|
||||
├─> IDE Setup (VS Code, Visual Studio, CLion, Code::Blocks)
|
||||
├─> Build Tools (Make, CMake, Ninja)
|
||||
├─> Debugging Tools (gdb, lldb, Visual Studio debugger)
|
||||
└─> Version Control (Git integration)
|
||||
```
|
||||
|
||||
### 1.2 Basic Syntax & Program Structure
|
||||
```
|
||||
┌──────────────────────────────┐
|
||||
│ Hello World Program │
|
||||
│ - #include directive │
|
||||
│ - main() function │
|
||||
│ - std::cout │
|
||||
│ - Return statement │
|
||||
└──────────────────────────────┘
|
||||
│
|
||||
├─> Compilation Process (Preprocessor → Compiler → Linker)
|
||||
├─> Header Files (.h vs .hpp)
|
||||
├─> Source Files (.cpp)
|
||||
└─> Comments (// vs /* */)
|
||||
```
|
||||
|
||||
### 1.3 Fundamental Data Types
|
||||
```
|
||||
┌──────────────────────────────┐
|
||||
│ Primitive Types │
|
||||
│ - int, short, long, long long│
|
||||
│ - float, double, long double │
|
||||
│ - char, wchar_t, char16_t │
|
||||
│ - bool │
|
||||
│ - void │
|
||||
└──────────────────────────────┘
|
||||
│
|
||||
├─> Type Modifiers (signed, unsigned, const, volatile)
|
||||
├─> sizeof Operator
|
||||
├─> Type Limits (#include <climits>, <cfloat>)
|
||||
└─> Type Aliases (typedef, using)
|
||||
```
|
||||
|
||||
### 1.4 Variables & Constants
|
||||
```
|
||||
┌──────────────────────────────┐
|
||||
│ Variable Declaration │
|
||||
│ - Initialization │
|
||||
│ - Assignment │
|
||||
│ - Scope (local, global) │
|
||||
└──────────────────────────────┘
|
||||
│
|
||||
├─> const Variables
|
||||
├─> constexpr (C++11)
|
||||
├─> Literal Constants
|
||||
├─> #define Preprocessor Constants
|
||||
└─> auto Type Deduction (C++11)
|
||||
```
|
||||
|
||||
### 1.5 Operators
|
||||
```
|
||||
┌──────────────────────────────┐
|
||||
│ Arithmetic Operators │
|
||||
│ Relational Operators │
|
||||
│ Logical Operators │
|
||||
│ Bitwise Operators │
|
||||
│ Assignment Operators │
|
||||
└──────────────────────────────┘
|
||||
│
|
||||
├─> Operator Precedence
|
||||
├─> sizeof Operator
|
||||
├─> Ternary Operator (?:)
|
||||
├─> Comma Operator
|
||||
└─> Type Casting Operators
|
||||
```
|
||||
|
||||
---
|
||||
|
||||
## Level 2: Control Flow (Requires Level 1)
|
||||
|
||||
### 2.1 Conditional Statements
|
||||
```
|
||||
┌──────────────────────────────┐
|
||||
│ if Statement │
|
||||
│ if-else Statement │
|
||||
│ if-else if-else │
|
||||
│ Nested if │
|
||||
└──────────────────────────────┘
|
||||
│
|
||||
├─> switch Statement
|
||||
├─> case Labels
|
||||
├─> default Case
|
||||
├─> break in switch
|
||||
└─> Ternary Operator Alternative
|
||||
```
|
||||
|
||||
### 2.2 Loops
|
||||
```
|
||||
┌──────────────────────────────┐
|
||||
│ while Loop │
|
||||
│ do-while Loop │
|
||||
│ for Loop │
|
||||
└──────────────────────────────┘
|
||||
│
|
||||
├─> Range-based for Loop (C++11)
|
||||
├─> Nested Loops
|
||||
├─> Loop Control (break, continue)
|
||||
├─> goto Statement (discouraged)
|
||||
└─> Infinite Loops
|
||||
```
|
||||
|
||||
---
|
||||
|
||||
## Level 3: Functions (Requires Level 1-2)
|
||||
|
||||
### 3.1 Function Basics
|
||||
```
|
||||
┌──────────────────────────────┐
|
||||
│ Function Declaration │
|
||||
│ Function Definition │
|
||||
│ Function Call │
|
||||
│ Return Statement │
|
||||
└──────────────────────────────┘
|
||||
│
|
||||
├─> Parameters & Arguments
|
||||
├─> Pass by Value
|
||||
├─> Default Parameters
|
||||
├─> void Functions
|
||||
└─> Function Prototypes
|
||||
```
|
||||
|
||||
### 3.2 Advanced Function Concepts
|
||||
```
|
||||
┌──────────────────────────────┐
|
||||
│ Function Overloading │
|
||||
│ Inline Functions │
|
||||
│ Recursion │
|
||||
└──────────────────────────────┘
|
||||
│
|
||||
├─> constexpr Functions (C++11)
|
||||
├─> consteval Functions (C++20)
|
||||
├─> [[nodiscard]] Attribute (C++17)
|
||||
└─> Trailing Return Types (C++11)
|
||||
```
|
||||
|
||||
---
|
||||
|
||||
## Level 4: Arrays & Strings (Requires Level 1-3)
|
||||
|
||||
### 4.1 Arrays
|
||||
```
|
||||
┌──────────────────────────────┐
|
||||
│ C-style Arrays │
|
||||
│ - Declaration & Init │
|
||||
│ - Array Indexing │
|
||||
│ - Multi-dimensional Arrays │
|
||||
└──────────────────────────────┘
|
||||
│
|
||||
├─> Array Decay to Pointer
|
||||
├─> Array Size Calculation
|
||||
├─> std::array (C++11)
|
||||
└─> Array Initialization Syntax
|
||||
```
|
||||
|
||||
### 4.2 Strings
|
||||
```
|
||||
┌──────────────────────────────┐
|
||||
│ C-style Strings │
|
||||
│ - char arrays │
|
||||
│ - String literals │
|
||||
│ - String manipulation │
|
||||
└──────────────────────────────┘
|
||||
│
|
||||
├─> std::string Class
|
||||
├─> String Operations
|
||||
├─> std::string_view (C++17)
|
||||
├─> Raw String Literals (C++11)
|
||||
└─> User-defined Literals (C++11)
|
||||
```
|
||||
|
||||
---
|
||||
|
||||
## Level 5: Pointers & References (Requires Level 1-4)
|
||||
|
||||
### 5.1 Pointers
|
||||
```
|
||||
┌──────────────────────────────┐
|
||||
│ Pointer Basics │
|
||||
│ - Address-of Operator (&) │
|
||||
│ - Dereference Operator (*) │
|
||||
│ - nullptr (C++11) │
|
||||
└──────────────────────────────┘
|
||||
│
|
||||
├─> Pointer Arithmetic
|
||||
├─> Pointers and Arrays
|
||||
├─> Pointer to Pointer
|
||||
├─> void Pointers
|
||||
├─> const Pointers
|
||||
├─> Function Pointers
|
||||
└─> Pointer Best Practices
|
||||
|
||||
┌──────────────────────────────┐
|
||||
│ Dynamic Memory │
|
||||
│ - new Operator │
|
||||
│ - delete Operator │
|
||||
│ - new[] & delete[] │
|
||||
│ - Memory Leaks │
|
||||
└──────────────────────────────┘
|
||||
│
|
||||
├─> Placement new
|
||||
├─> Memory Allocation Failures
|
||||
├─> std::nothrow
|
||||
└─> RAII Principle
|
||||
```
|
||||
|
||||
### 5.2 References
|
||||
```
|
||||
┌──────────────────────────────┐
|
||||
│ Reference Basics │
|
||||
│ - Declaration & Init │
|
||||
│ - References vs Pointers │
|
||||
│ - const References │
|
||||
└──────────────────────────────┘
|
||||
│
|
||||
├─> Pass by Reference
|
||||
├─> Return by Reference
|
||||
├─> Reference Members
|
||||
├─> rvalue References (C++11)
|
||||
└─> Universal References
|
||||
|
||||
┌──────────────────────────────┐
|
||||
│ Pass by Reference │
|
||||
│ Pass by Value │
|
||||
│ Pass by Pointer │
|
||||
│ When to Use Which │
|
||||
└──────────────────────────────┘
|
||||
```
|
||||
|
||||
---
|
||||
|
||||
## Level 6: Object-Oriented Programming (Requires Level 1-5)
|
||||
|
||||
### 6.1 Classes & Objects
|
||||
```
|
||||
┌──────────────────────────────┐
|
||||
│ Class Definition │
|
||||
│ - Data Members │
|
||||
│ - Member Functions │
|
||||
│ - Access Specifiers │
|
||||
│ (public, private, protected)│
|
||||
└──────────────────────────────┘
|
||||
│
|
||||
├─> this Pointer
|
||||
├─> Object Creation
|
||||
├─> Member Initialization
|
||||
├─> Static Members
|
||||
├─> Friend Functions/Classes
|
||||
└─> Nested Classes
|
||||
```
|
||||
|
||||
### 6.2 Constructors & Destructors
|
||||
```
|
||||
┌──────────────────────────────┐
|
||||
│ Constructors │
|
||||
│ - Default Constructor │
|
||||
│ - Parameterized Constructor │
|
||||
│ - Copy Constructor │
|
||||
│ - Constructor Overloading │
|
||||
└──────────────────────────────┘
|
||||
│
|
||||
├─> Move Constructor (C++11)
|
||||
├─> Delegating Constructors (C++11)
|
||||
├─> Initializer Lists
|
||||
├─> explicit Keyword
|
||||
├─> Converting Constructors
|
||||
└─> Constructor Member Initializer
|
||||
|
||||
┌──────────────────────────────┐
|
||||
│ Destructors │
|
||||
│ - Resource Cleanup │
|
||||
│ - Virtual Destructors │
|
||||
│ - Rule of Three/Five/Zero │
|
||||
└──────────────────────────────┘
|
||||
│
|
||||
├─> RAII (Resource Acquisition Is Initialization)
|
||||
├─> Default/Delete (C++11)
|
||||
└─> noexcept Destructors
|
||||
```
|
||||
|
||||
### 6.3 Operator Overloading
|
||||
```
|
||||
┌──────────────────────────────┐
|
||||
│ Overloadable Operators │
|
||||
│ - Arithmetic (+, -, *, /) │
|
||||
│ - Comparison (==, !=, <, >) │
|
||||
│ - Assignment (=) │
|
||||
│ - Stream (<<, >>) │
|
||||
└──────────────────────────────┘
|
||||
│
|
||||
├─> Member vs Non-member Overloading
|
||||
├─> Subscript Operator []
|
||||
├─> Function Call Operator ()
|
||||
├─> Increment/Decrement (++, --)
|
||||
├─> Conversion Operators
|
||||
└─> Spaceship Operator <=> (C++20)
|
||||
```
|
||||
|
||||
### 6.4 Inheritance
|
||||
```
|
||||
┌──────────────────────────────┐
|
||||
│ Single Inheritance │
|
||||
│ - Base & Derived Classes │
|
||||
│ - Access Control │
|
||||
│ - Constructor Chaining │
|
||||
└──────────────────────────────┘
|
||||
│
|
||||
├─> Multiple Inheritance
|
||||
├─> Virtual Inheritance
|
||||
├─> Diamond Problem
|
||||
├─> protected Members
|
||||
├─> Inheritance Types (public, protected, private)
|
||||
└─> Slicing Problem
|
||||
|
||||
┌──────────────────────────────┐
|
||||
│ Polymorphism │
|
||||
│ - Virtual Functions │
|
||||
│ - Pure Virtual Functions │
|
||||
│ - Abstract Classes │
|
||||
└──────────────────────────────┘
|
||||
│
|
||||
├─> Virtual Destructors
|
||||
├─> Virtual Function Tables (vtable)
|
||||
├─> Dynamic Binding
|
||||
├─> override Keyword (C++11)
|
||||
├─> final Keyword (C++11)
|
||||
└─> Runtime Type Information (RTTI)
|
||||
```
|
||||
|
||||
---
|
||||
|
||||
## Level 7: Templates (Requires Level 6)
|
||||
|
||||
### 7.1 Function Templates
|
||||
```
|
||||
┌──────────────────────────────┐
|
||||
│ Template Syntax │
|
||||
│ - template<typename T> │
|
||||
│ - Template Parameters │
|
||||
│ - Template Instantiation │
|
||||
└──────────────────────────────┘
|
||||
│
|
||||
├─> Explicit Instantiation
|
||||
├─> Template Specialization
|
||||
├─> Function Template Overloading
|
||||
├─> Template Argument Deduction
|
||||
└─> typename vs class Keyword
|
||||
```
|
||||
|
||||
### 7.2 Class Templates
|
||||
```
|
||||
┌──────────────────────────────┐
|
||||
│ Template Classes │
|
||||
│ - Member Functions │
|
||||
│ - Static Members │
|
||||
│ - Template Methods │
|
||||
└──────────────────────────────┘
|
||||
│
|
||||
├─> Class Template Specialization
|
||||
├─> Partial Specialization
|
||||
├─> Non-type Template Parameters
|
||||
├─> Default Template Arguments
|
||||
├─> Template Template Parameters
|
||||
└─> Friend Templates
|
||||
```
|
||||
|
||||
### 7.3 Advanced Templates
|
||||
```
|
||||
┌──────────────────────────────┐
|
||||
│ Variadic Templates (C++11) │
|
||||
│ - Parameter Packs │
|
||||
│ - Pack Expansion │
|
||||
│ - Fold Expressions (C++17) │
|
||||
└──────────────────────────────┘
|
||||
│
|
||||
├─> SFINAE (Substitution Failure Is Not An Error)
|
||||
├─> std::enable_if
|
||||
├─> Type Traits
|
||||
├─> if constexpr (C++17)
|
||||
├─> Concepts (C++20)
|
||||
└─> Requires Clauses (C++20)
|
||||
```
|
||||
|
||||
---
|
||||
|
||||
## Level 8: Modern C++ Features (Requires Level 1-7)
|
||||
|
||||
### 8.1 Smart Pointers (C++11)
|
||||
```
|
||||
┌──────────────────────────────┐
|
||||
│ std::unique_ptr │
|
||||
│ - Exclusive Ownership │
|
||||
│ - Move-only Semantics │
|
||||
│ - Custom Deleters │
|
||||
└──────────────────────────────┘
|
||||
│
|
||||
├─> std::shared_ptr
|
||||
├─> std::weak_ptr
|
||||
├─> make_unique (C++14)
|
||||
├─> make_shared
|
||||
├─> Circular Reference Problem
|
||||
└─> When to Use Which
|
||||
```
|
||||
|
||||
### 8.2 Move Semantics (C++11)
|
||||
```
|
||||
┌──────────────────────────────┐
|
||||
│ lvalue vs rvalue │
|
||||
│ rvalue References (&&) │
|
||||
│ std::move │
|
||||
│ std::forward │
|
||||
└──────────────────────────────┘
|
||||
│
|
||||
├─> Move Constructor
|
||||
├─> Move Assignment Operator
|
||||
├─> Perfect Forwarding
|
||||
├─> Reference Collapsing
|
||||
├─> Universal References
|
||||
└─> Return Value Optimization (RVO, NRVO)
|
||||
```
|
||||
|
||||
### 8.3 Lambda Expressions (C++11)
|
||||
```
|
||||
┌──────────────────────────────┐
|
||||
│ Lambda Syntax │
|
||||
│ - [capture](params){} │
|
||||
│ - Capture Clauses │
|
||||
│ - Return Type Deduction │
|
||||
└──────────────────────────────┘
|
||||
│
|
||||
├─> Capture Modes ([=], [&], [this], [*this])
|
||||
├─> Generic Lambdas (C++14)
|
||||
├─> Init Capture (C++14)
|
||||
├─> constexpr Lambdas (C++17)
|
||||
├─> Template Lambdas (C++20)
|
||||
└─> Lambda as Function Objects
|
||||
```
|
||||
|
||||
### 8.4 Standard Library Enhancements
|
||||
```
|
||||
┌──────────────────────────────┐
|
||||
│ C++11 Features │
|
||||
│ - auto, decltype │
|
||||
│ - nullptr │
|
||||
│ - constexpr │
|
||||
│ - Range-based for │
|
||||
└──────────────────────────────┘
|
||||
│
|
||||
├─> C++14: Generic lambdas, digit separators
|
||||
├─> C++17: Structured bindings, optional, variant, any
|
||||
├─> C++20: Concepts, ranges, coroutines, modules
|
||||
└─> C++23: std::expected, multidimensional subscript
|
||||
```
|
||||
|
||||
---
|
||||
|
||||
## Level 9: STL - Standard Template Library (Requires Level 7-8)
|
||||
|
||||
### 9.1 Containers
|
||||
```
|
||||
┌──────────────────────────────┐
|
||||
│ Sequence Containers │
|
||||
│ - vector, deque, list │
|
||||
│ - forward_list, array │
|
||||
└──────────────────────────────┘
|
||||
│
|
||||
├─> Associative Containers (set, map, multiset, multimap)
|
||||
├─> Unordered Containers (unordered_set, unordered_map)
|
||||
├─> Container Adaptors (stack, queue, priority_queue)
|
||||
├─> span (C++20)
|
||||
└─> Container Selection Guidelines
|
||||
|
||||
┌──────────────────────────────┐
|
||||
│ Container Operations │
|
||||
│ - Insertion, Deletion │
|
||||
│ - Access, Search │
|
||||
│ - Iteration │
|
||||
└──────────────────────────────┘
|
||||
│
|
||||
├─> Iterator Invalidation
|
||||
├─> Container Complexity (Big-O)
|
||||
└─> Container Performance Characteristics
|
||||
```
|
||||
|
||||
### 9.2 Iterators
|
||||
```
|
||||
┌──────────────────────────────┐
|
||||
│ Iterator Categories │
|
||||
│ - Input/Output Iterators │
|
||||
│ - Forward/Bidirectional │
|
||||
│ - Random Access Iterators │
|
||||
└──────────────────────────────┘
|
||||
│
|
||||
├─> Iterator Adaptors (reverse, insert, stream)
|
||||
├─> Iterator Traits
|
||||
├─> begin() / end()
|
||||
├─> cbegin() / cend()
|
||||
├─> rbegin() / rend()
|
||||
└─> Custom Iterators
|
||||
```
|
||||
|
||||
### 9.3 Algorithms
|
||||
```
|
||||
┌──────────────────────────────┐
|
||||
│ Non-modifying Algorithms │
|
||||
│ - find, count, search │
|
||||
│ - min, max, accumulate │
|
||||
└──────────────────────────────┘
|
||||
│
|
||||
├─> Modifying Algorithms (copy, transform, replace)
|
||||
├─> Sorting (sort, stable_sort, partial_sort)
|
||||
├─> Binary Search (lower_bound, upper_bound)
|
||||
├─> Heap Operations
|
||||
├─> Numeric Algorithms
|
||||
└─> Ranges (C++20)
|
||||
```
|
||||
|
||||
### 9.4 Function Objects & Utilities
|
||||
```
|
||||
┌──────────────────────────────┐
|
||||
│ Function Objects (Functors) │
|
||||
│ - operator() Overloading │
|
||||
│ - std::function │
|
||||
│ - std::bind │
|
||||
└──────────────────────────────┘
|
||||
│
|
||||
├─> Standard Functors (plus, minus, less, greater)
|
||||
├─> Predicate Functions
|
||||
├─> Lambda as Functors
|
||||
└─> Function Pointers vs Functors
|
||||
```
|
||||
|
||||
---
|
||||
|
||||
## Level 10: Memory Management (Requires Level 5-8)
|
||||
|
||||
### 10.1 Manual Memory Management
|
||||
```
|
||||
┌──────────────────────────────┐
|
||||
│ Stack vs Heap │
|
||||
│ new & delete │
|
||||
│ Memory Leaks │
|
||||
│ Dangling Pointers │
|
||||
└──────────────────────────────┘
|
||||
│
|
||||
├─> Memory Alignment
|
||||
├─> Placement new
|
||||
├─> Custom Allocators
|
||||
├─> Memory Pools
|
||||
└─> Object Pools
|
||||
```
|
||||
|
||||
### 10.2 Advanced Memory Concepts
|
||||
```
|
||||
┌──────────────────────────────┐
|
||||
│ Memory Order & Layout │
|
||||
│ - Structure Padding │
|
||||
│ - alignof, alignas │
|
||||
│ - Cache-friendly Structures │
|
||||
└──────────────────────────────┘
|
||||
│
|
||||
├─> Memory Profiling Tools
|
||||
├─> Valgrind, AddressSanitizer
|
||||
├─> Memory Leak Detection
|
||||
└─> Memory Optimization Techniques
|
||||
```
|
||||
|
||||
---
|
||||
|
||||
## Level 11: Concurrency (Requires Level 1-10)
|
||||
|
||||
### 11.1 Threading Basics
|
||||
```
|
||||
┌──────────────────────────────┐
|
||||
│ std::thread │
|
||||
│ - Thread Creation │
|
||||
│ - Thread Joining │
|
||||
│ - Thread Detaching │
|
||||
└──────────────────────────────┘
|
||||
│
|
||||
├─> Thread Local Storage
|
||||
├─> Thread IDs
|
||||
├─> Hardware Concurrency
|
||||
└─> Thread Management
|
||||
```
|
||||
|
||||
### 11.2 Synchronization
|
||||
```
|
||||
┌──────────────────────────────┐
|
||||
│ Mutexes │
|
||||
│ - std::mutex │
|
||||
│ - std::recursive_mutex │
|
||||
│ - std::timed_mutex │
|
||||
└──────────────────────────────┘
|
||||
│
|
||||
├─> Lock Guards (std::lock_guard, std::unique_lock)
|
||||
├─> Condition Variables
|
||||
├─> std::atomic
|
||||
├─> Memory Ordering
|
||||
├─> std::future & std::promise
|
||||
└─> std::async
|
||||
|
||||
┌──────────────────────────────┐
|
||||
│ Thread Safety │
|
||||
│ - Data Races │
|
||||
│ - Race Conditions │
|
||||
│ - Deadlocks │
|
||||
└──────────────────────────────┘
|
||||
│
|
||||
├─> Lock-free Programming
|
||||
├─> Wait-free Programming
|
||||
├─> Compare-and-Swap (CAS)
|
||||
└─> Thread-safe Data Structures
|
||||
```
|
||||
|
||||
---
|
||||
|
||||
## Level 12: Exception Handling & Error Management (Requires Level 6)
|
||||
|
||||
### 12.1 Exceptions
|
||||
```
|
||||
┌──────────────────────────────┐
|
||||
│ try-catch Blocks │
|
||||
│ throw Statement │
|
||||
│ Standard Exceptions │
|
||||
│ Custom Exceptions │
|
||||
└──────────────────────────────┘
|
||||
│
|
||||
├─> Exception Specifications (deprecated)
|
||||
├─> noexcept (C++11)
|
||||
├─> Exception Safety Guarantees
|
||||
├─> RAII for Exception Safety
|
||||
└─> Stack Unwinding
|
||||
```
|
||||
|
||||
### 12.2 Error Handling Strategies
|
||||
```
|
||||
┌──────────────────────────────┐
|
||||
│ Error Codes vs Exceptions │
|
||||
│ std::optional (C++17) │
|
||||
│ std::expected (C++23) │
|
||||
│ std::variant (C++17) │
|
||||
└──────────────────────────────┘
|
||||
│
|
||||
└─> Error Handling Best Practices
|
||||
```
|
||||
|
||||
---
|
||||
|
||||
## 🔗 Dependency Map Summary
|
||||
|
||||
### Critical Learning Path
|
||||
```
|
||||
Level 1 (Basics)
|
||||
→ Level 2 (Control Flow)
|
||||
→ Level 3 (Functions)
|
||||
→ Level 4 (Arrays & Strings)
|
||||
→ Level 5 (Pointers & References)
|
||||
→ Level 6 (OOP)
|
||||
→ Level 7 (Templates)
|
||||
→ Level 8 (Modern C++) [can parallel with 9-11]
|
||||
→ Level 9 (STL)
|
||||
→ Level 10 (Memory)
|
||||
→ Level 11 (Concurrency) [can parallel with 10]
|
||||
→ Level 12 (Exceptions)
|
||||
```
|
||||
|
||||
### Parallel Learning Opportunities
|
||||
- Levels 8, 9, 10, 11 can be learned in parallel after mastering Level 7
|
||||
- Exception handling (Level 12) can be introduced earlier but fully mastered later
|
||||
- Modern C++ features can be learned alongside traditional concepts
|
||||
|
||||
---
|
||||
|
||||
## 📊 Prerequisite Matrix
|
||||
|
||||
| Topic | Must Know First | Can Learn In Parallel |
|
||||
|-------|----------------|----------------------|
|
||||
| Pointers | Arrays, Functions | References |
|
||||
| References | Pointers basics | - |
|
||||
| Classes | Pointers, References | - |
|
||||
| Templates | Classes, Functions | - |
|
||||
| Smart Pointers | Pointers, RAII, Templates | Move Semantics |
|
||||
| Move Semantics | References, OOP | Smart Pointers |
|
||||
| STL | Templates, OOP | Modern C++ Features |
|
||||
| Concurrency | Pointers, References, OOP | Memory Management |
|
||||
| Lambdas | Functions, OOP | Templates |
|
||||
|
||||
---
|
||||
|
||||
This knowledge graph ensures you build strong foundations before tackling advanced C++ concepts!
|
||||
|
||||
Reference in New Issue
Block a user