⚡ Embedded Modern C++ Complete Curriculum (116 Projects)

Embedded Modern C++: From Bare-Metal to STL

Comprehensive, deep-dive architectural analysis of all 116 course projects across Sections 1 through 12. Complete with fully annotated source code, ARM Cortex-M hardware realities, zero-overhead refactors, and interactive self-checking quizzes.

🎓 Upstream Curriculum & Repository Attribution

Built upon the curriculum and project code of The Complete C++ Developer Course by Packt Publishing (Dr. John P. Baugh). This portal serves as an advanced companion resource—expanding foundational C++ code into production-grade embedded systems architectures, deterministic real-time patterns, ARM Cortex-M hardware analyses, and interactive quizzes.

📖 Technical Glossary (68+ Terms) 📂 GitHub Repository 📖 Course Syllabus & Setup Guide ⚡ ARM Cortex-M & MISRA C++ Focus
116
Total Projects
Projects 1.01 – 12.10
12
Domain Sections
Sec 1 – Sec 12
68+
Glossary Terms
Hardware & Modern STL
2
Curriculum Tracks
Foundations & Advanced
🔍
Filter by Section:
Showing 116 of 116 Projects
📘

Track 1: Foundations & Core Language Architecture

Sections 1 through 6 • Projects 1.01 – 6.06 • Cross-Compilers, Data Types, Control Flow, Memory Locality, Calling Conventions & OOP Foundations

61 Projects (1.01–6.06)
Section 1 #1.01
⚡ Critical

1.01 Hello (Visual Studio / MSVC)

Exploring the classic C++ entry point. We deconstruct the 4 stages of the C++ compilation pipeline (Preprocessor,...

Toolchains Preprocessing Compilation
Section 1 #1.02
⚡ Critical

1.02 VSC Hello (Cross-Compilation & Toolchains)

Building modern C++ projects using cross-platform toolchains (VS Code, CMake, Ninja). We dissect Host vs Target...

Cross-Compilation arm-none-eabi-gcc GDB
Section 2 #2.01
⚡ High

2.01 HelloWorld

Exploring console output via std::cout and std::endl. We analyze why C++ iostreams introduce 20KB-50KB of binary Flash...

std::cout UART Semihosting
Section 2 #2.02
⚡ Core

2.02 CommentFun

Exploring single-line (//) and multi-line (/* */) comments. We analyze Doxygen documentation tag standards for embedded...

Comments Doxygen Documentation
Section 2 #2.03
⚡ Critical

2.03 VariableFun

Exploring fundamental C++ data types (int, double, char, bool). We demonstrate why non-standardized integer widths...

uint8_t uint32_t
Section 2 #2.04
⚡ Core

2.04 TextFun

Exploring character types and escape sequences. We examine ASCII encoding tables, character-to-integer conversion, and...

char ASCII Escape Sequences
Section 2 #2.05
⚡ Critical

2.05 ArithmeticFun

Analyzing arithmetic operators (+, -, *, /, %). We explore C++ Integer Promotion rules (small integer types are...

Arithmetic Integer Promotion Signed Overflow UB
Section 2 #2.06
⚡ Core

2.06 RelationalFun

Exploring relational comparison operators. We demonstrate why exact equality comparisons (==) on floating-point numbers...

Relational Operators Epsilon Comparison ARM Flags
Section 2 #2.07
⚡ Critical

2.07 LogicalFun

Exploring logical operators (&&, ||, !). We analyze Short-Circuit Evaluation, demonstrate how short-circuiting provides...

Logical Operators Short-Circuit Null Guards
Section 2 #2.08
⚡ High

2.08 BooleanFun

Exploring the boolean data type. We analyze why sizeof(bool) occupies a full 8 bits (1 byte) in memory rather than 1...

bool Bitfields Bitmasks
Section 2 #2.09
⚡ Critical

2.09 ConstantFun

Analyzing constants in C++. We contrast legacy C preprocessor macros (#define) with type-safe const and compile-time...

constexpr const #define
Section 2 #2.10
⚡ Core

2.10 KeyboardInput

Exploring keyboard user input via std::cin. We examine the hazards of blocking I/O in real-time systems, stream fail...

std::cin Blocking I/O UART RX
Section 2 #2.11
⚡ Core

2.11 SunnyWarm

Analyzing compound boolean logic and truth tables. We explore De Morgan's Laws for simplifying complex nested...

De Morgan's Laws Boolean Logic Truth Tables
Section 2 #2.12
⚡ Core

2.12 Percentages

Calculating percentage ratios from integer variables. We examine the classic beginner integer division pitfall (e.g....

Integer Scaling Precision Loss Multiply-Before-Divide
Section 2 #2.13
⚡ Core

2.13 TipCalculator

Building tip and tax computation utilities. We explore why floating-point types (float, double) are strictly banned in...

Fixed-Point Cents Math Currency
Section 2 #2.14
⚡ Core

2.14 SecretAgentID

Building security identifier formatting and user credential validation. We analyze formatted I/O manipulation, string...

String Parsing Buffer Safety Security Tokens
Section 3 #3.01
⚡ Critical

3.01 ControlStatementsIntro

Exploring the foundations of programmatic control flow. We analyze sequential instruction fetching, conditional...

Control Flow Branches Pipeline Flushes
Section 3 #3.02
⚡ Core

3.02 SelectionFun

Exploring if/else selection statements and multi-branch decision trees. We contrast deeply nested if-else ladders...

if/else Decision Trees Guard Clauses
Section 3 #3.03
⚡ Core

3.03 RetiredWomen

Analyzing multi-variable conditional logic (age, gender, employment status). We examine Karnaugh Map boolean logic...

Boolean Logic Karnaugh Maps Safety Interlocks
Section 3 #3.04
⚡ Critical

3.04 GradeFun

Exploring multi-case selection via switch statements vs if-else chains. We analyze compiler jump table generation (ARM...

switch Jump Tables TBB / TBH
Section 3 #3.05
⚡ Core

3.05 LeapYearChecker

Implementing Gregorian calendar leap year determination. We examine the exact three-tier leap year algorithm (divisible...

RTC Epoch Time Leap Year
Section 3 #3.06
⚡ Core

3.06 RockPaperScissors

Building interactive decision trees and win/loss resolution matrices. We model cyclical dominance relationships (Rock...

State Machines Enums Transition Matrix
Section 3 #3.07
⚡ Core

3.07 RepetitionFun

Exploring loop structures: while (pre-test), do-while (post-test), and for loops. We analyze their assembly generation...

while do-while for loops
Section 3 #3.08
⚡ Core

3.08 SumFun

Accumulating numeric series with loops. We contrast iterative $O(N)$ loop summation with Gauss's closed-form arithmetic...

Accumulator Gauss Formula Arithmetic Series
Section 3 #3.09
⚡ Core

3.09 EvenOnly

Generating even-number sequences. We demonstrate why advancing the loop step size directly (i += 2) executes twice as...

Loop Stride Filtering Branch Reduction
Section 3 #3.10
⚡ Core

3.10 ContinueBreak

Analyzing loop interruption statements: break (immediate loop exit) and continue (skip to next iteration). We explore...

break continue Early Exit
Section 3 #3.11
⚡ High

3.11 DieRolls

Exploring random number generation and dice simulation. We analyze the severe cryptographic and statistical flaws of...

PRNG TRNG Hardware RNG
Section 3 #3.12
⚡ Core

3.12 RandomFun

Exploring the Modern C++ library introduced in C++11. We contrast legacy C rand() with modern random engines (Mersenne...

std::mt19937 uniform_int_distribution
Section 3 #3.13
⚡ Core

3.13 StreamingCalculator

Building a streaming arithmetic calculator with continuous input parsing. We analyze character stream tokenization,...

Stream Parsing CLI Command Dispatcher
Section 4 #4.01
⚡ Critical

4.01 ArrayFun

Exploring foundational C-style arrays on the CPU stack. We examine array declaration, zero-based indexing, how arrays...

C-Style Arrays Stack Memory Array Decay
Section 4 #4.02
⚡ Core

4.02 ArrayFunTest

Analyzing array initialization syntax, calculating element counts via sizeof, and the dangers of uninitialized stack...

Array Initialization Value Init {} Garbage RAM
Section 4 #4.03
⚡ Core

4.03 MoreArrayFun

Exploring C++11 range-based for loops over arrays. We inspect compiler assembly generation, loop unrolling...

Range-Based For Iteration Loop Unrolling
Section 4 #4.04
⚡ Core

4.04 TwiceNumbers

Populating arrays through algorithmic generation and mutating elements in place. We explore ARM Cortex-M4/M7 DSP SIMD...

In-Place Mutation SIMD ARM DSP
Section 4 #4.05
⚡ High

4.05 NamesArray

Comparing arrays of std::string objects with lightweight string_view arrays. We reveal how an array of std::string...

std::string std::string_view Heap Overhead
Section 4 #4.06
⚡ High

4.06 TemperatureConverter

Converting temperature sensor readings stored in arrays. We explore the memory difference between float (32-bit IEEE...

Floating Point FPU Fixed-Point Math
Section 4 #4.07
⚡ Critical

4.07 2DArrayFun

Deep dive into two-dimensional arrays in C++. We examine row-major contiguous memory layouts, why row-first iteration...

2D Arrays Row-Major DMA Transfers
Section 4 #4.08
⚡ Core

4.08 MoveRatings

Manipulating 2D data grids with nested loops. We explore matrix processing patterns, row vs column accumulation, and...

Matrix Math Nested Loops Cache Lines
Section 4 #4.09
⚡ Critical

4.09 VectorFun

Exploring dynamic arrays via std::vector. We analyze capacity vs size, geometric heap reallocation mechanics, pointer...

std::vector push_back Capacity vs Size
Section 4 #4.10
⚡ Core

4.10 VectorPractice

Practicing vector modification operations: push_back, pop_back, and insert. We examine the O(N) element shifting cost...

pop_back() insert() ETL
Section 4 #4.11
⚡ Core

4.11 ShoppingList

Building dynamic list management with interactive user input. We contrast general-purpose dynamic list manipulation...

Vector Modification FIFO Queue Circular Buffer
Section 5 #5.01
⚡ Critical

5.01 FunctionFun1

Exploring function prototypes, definitions, and execution flow. We analyze the ARM Architecture Procedure Call Standard...

Prototypes AAPCS Stack Frames
Section 5 #5.02
⚡ Critical

5.02 PassingSchemes

Comprehensive comparative study of the three parameter passing schemes: pass-by-value, pass-by-reference (&), and...

Pass-by-Value Pass-by-Reference const&
Section 5 #5.03
⚡ High

5.03 FunctionOverloading

Analyzing function overloading in C++. We examine compiler name mangling, resolving ambiguous type promotions, and how...

Overloading Name Mangling extern "C"
Section 5 #5.04
⚡ Critical

5.04 FactorialFun

Exploring recursive algorithms vs iterative implementations. We demonstrate why unbounded recursion is banned in...

Recursion Stack Overflow constexpr
Section 5 #5.05
⚡ High

5.05 MathFun

Exploring mathematical functions in (pow, sqrt, abs). We analyze why generic floating-point math libraries cause Flash...

FPU CORDIC
Section 5 #5.06
⚡ Critical

5.06 CountDown

Exploring loop countdowns and delays. We demonstrate why software busy-wait loops (for(volatile int i=0...)) waste...

Hardware Timers SysTick vTaskDelay
Section 5 #5.07
⚡ Core

5.07 CountEvens

Analyzing parity checks and filtering in arrays. We contrast expensive hardware division (num % 2) with single-cycle...

Bitwise & Modulo % Branchless
Section 5 #5.08
⚡ Core

5.08 AverageOfThree

Calculating statistical averages. We explore integer division truncation, precision loss in sensor data processing, and...

Integer Division Truncation Rounding Math
Section 5 #5.09
⚡ Core

5.09 ParameterChallenge

Exploring functions that return multiple values via pass-by-reference out-parameters. We compare legacy out-parameters...

Pass-by-Reference Out Parameters Multiple Returns
Section 5 #5.10
⚡ High

5.10 ProductArrayByReference

Passing fixed arrays by reference (int(&)[N]) to prevent pointer decay. We analyze template-based array references and...

Array References std::span Size Preservation
Section 5 #5.11
⚡ Core

5.11 ProductArrayObject

Using std::array as an object container. We demonstrate how std::array provides STL iterator compatibility (begin/end)...

std::array Zero-Cost Abstraction Iterators
Section 5 #5.12
⚡ Core

5.12 ReturnTypeParameterFun

Exploring return types and function side effects. We examine pure functions vs state-mutating functions and demonstrate...

Return Types Pure Functions [[nodiscard]]
Section 5 #5.13
⚡ Critical

5.13 ScopeFun

Analyzing variable scope and lifetime: local (automatic stack), global, and local static storage. We analyze the memory...

Scope Lifetime Static Variables
Section 5 #5.14
⚡ Core

5.14 ScopeChallenge

Practicing scope resolution and diagnosing variable shadowing bugs. We explore anonymous namespaces in C++ vs static...

Variable Shadowing Anonymous Namespaces static linkage
Section 5 #5.15
⚡ High

5.15 TicTacToe

Building a full interactive Tic-Tac-Toe system. We analyze functional modular decomposition, separation of display...

State Machines Modularity Matrix Grid
Section 6 #6.01
⚡ High

6.01 BookFun

Exploring foundational C++ classes: access specifiers (public vs private), member functions, constructors, and...

Classes vs Structs Encapsulation Struct Padding
Section 6 #6.02
⚡ Core

6.02 RectangleFun

Building geometric classes with constructors and member initializer lists. We analyze why member initializer lists are...

Member Initializer List constexpr OOP
Section 6 #6.03
⚡ Core

6.03 Houses

Instantiating and managing multiple distinct class objects. We examine memory footprints of multiple instances in SRAM,...

Instances Memory Stride Array of Objects
Section 6 #6.04
⚡ Core

6.04 LibraryCardProject

Designing classes that enforce strict data validation rules through encapsulation. We analyze invariant preservation in...

Invariants Validation OOP
Section 6 #6.05
⚡ Core

6.05 SundaeProject

Building composite objects through composition (HAS-A relationships). We examine constructor and destructor execution...

Composition HAS-A Destructors
Section 6 #6.06
⚡ Critical

6.06 TriangleProject

Building validated geometric triangle classes enforcing the Triangle Inequality Theorem. We explore how global object...

Triangle Inequality Invariants Static Initialization Fiasco
🚀

Track 2: Advanced Systems, Real-Time Hardware & Memory

Sections 7 through 12 • Projects 7.01 – 12.10 • Fault Handlers, Memory-Mapped I/O, Flash File Systems, Polymorphism & CRTP, Modern STL & Data Structures

55 Projects (7.01–12.10)
Section 7 #7.01
⚡ Critical

7.01 BugFun

Exploring the taxonomy of bugs: syntax errors, runtime faults, and subtle logic errors. In bare-metal systems, logic...

HardFault MemManage Stack Smashing
Section 7 #7.02
⚡ High

7.02 CustomExceptions

Building domain-specific exception hierarchies by inheriting from std::runtime_error and std::exception. We analyze how...

std::exception what() Object Slicing
Section 7 #7.03
⚡ Core

7.03 DogFun

Enforcing domain invariants through constructor validation and member validation methods. We examine the classic C++...

Invariants Constructor Failure Two-Phase Init
Section 7 #7.04
⚡ High

7.04 ExceptionFun1

Foundational try, throw, and catch mechanics in C++. We examine standard runtime exceptions (std::runtime_error), how...

try-catch std::runtime_error Stack Unwinding
Section 7 #7.05
⚡ Critical

7.05 FuelMonitorProject

Building a safety-critical fuel level monitoring system with custom exception triggers. We analyze how embedded systems...

Safety Critical Fail-Safe Threshold Monitoring
Section 7 #7.06
⚡ Core

7.06 LogicErrorFun

Analyzing std::logic_error and std::out_of_range exceptions in C++. We explore how out-of-bounds memory accesses...

std::logic_error std::out_of_range Bounds Checking
Section 7 #7.07
⚡ Core

7.07 MonthNameProject

Validating user input ranges and mapping integer IDs to string representations. We contrast exception-based validation...

Lookup Tables constexpr ROM Optimization
Section 7 #7.08
⚡ High

7.08 PersonFun

Deep dive into throwing exceptions from class constructors. We examine the classic C++ memory leak hazard when...

Constructor Exceptions Resource Leak noexcept
Section 7 #7.09
⚡ High

7.09 RethrowFun1

Examining multi-layered exception handling and exception rethrowing with throw;. We contrast standard C++ exception...

throw; Exception Slicing RTOS
Section 8 #8.01
⚡ Critical

8.01 PointerFun

Exploring the fundamentals of pointers: memory addresses, the address-of operator (&), and dereferencing (*). In...

Pointers Address-of & Dereference *
Section 8 #8.02
⚡ Critical

8.02 ConstCorrectness

Mastering the four permutations of const with pointers: mutable pointer to mutable data, pointer to const data, const...

const ROM-ability .rodata
Section 8 #8.03
⚡ Critical

8.03 DynamicFun

Analyzing dynamic memory allocation via new and delete, pointer resets to nullptr, and dangling pointer hazards. We...

new delete Heap Fragmentation
Section 8 #8.04
⚡ Core

8.04 DynamicDogs

Exploring object member access via pointer: the arrow operator (->) vs explicit dereferencing (*ptr).member. We analyze...

Arrow Operator -> Dereference Dot (*ptr). Object Lifecycles
Section 8 #8.05
⚡ High

8.05 DynamicArrayTest

Analyzing dynamic array allocation with new[] and deallocation with delete[]. We explain the undefined behavior of...

new[] delete[] Bounded Arrays
Section 8 #8.06
⚡ High

8.06 DroneFleet

Analyzing dynamic fleet management using double pointer indirection (Drone**). We contrast pointer-to-pointer...

Double Indirection Pointer to Pointer Cache Locality
Section 8 #8.07
⚡ High

8.07 ExhibitTracker

Tracking museum exhibits via a fixed array of heap pointers (Exhibit* exhibitPtrs[COUNT]). We explore the cleanup...

Array of Pointers Fixed-Block Allocator Intrusive List
Section 9 #9.01
⚡ Critical

9.01 FileInputFun

Exploring file reading via std::ifstream. We analyze file stream opening, buffer extraction, EOF detection, and...

std::ifstream LittleFS FatFS
Section 9 #9.02
⚡ High

9.02 FileOutputFun

Exploring file writing via std::ofstream. We analyze write buffering, explicit stream flushing, the severe hazard of...

std::ofstream Buffering Power Loss
Section 9 #9.03
⚡ Core

9.03 TwiceFile

Building read-transform-write file pipelines. We analyze streaming mathematical transformation of files and compare...

Streams Data Pipeline EEPROM
Section 9 #9.04
⚡ Core

9.04 NamesAges

Synchronizing parallel file streams (names.txt and ages.txt). We analyze stream synchronization, detecting mismatched...

Parallel Streams Record Synchronization Relational Data
Section 9 #9.05
⚡ Core

9.05 MovieGenres

Analyzing category frequency distributions and histograms from file streams. We explore fixed-size category binning,...

Histograms Categorization Frequency Table
Section 9 #9.06
⚡ Core

9.06 EmployeeSalaryReport

Generating formatted tabular text reports using (std::setw, std::setprecision, std::fixed). We analyze table column...

setw setprecision
Section 9 #9.07
⚡ Critical

9.07 StudentRoster

Building class object serialization and roster persistence. We compare text-based serialization with raw binary struct...

Serialization Binary Structs CRC32
Section 10 #10.01
⚡ High

10.01 EnumFun

Explores the transition from legacy C-style unscoped enum to modern C++11 enum class. Examines type safety, namespace...

Scoped Enums uint8_t Jump Tables
Section 10 #10.02
⚡ Critical

10.02 AnimalFun

Exploring abstract classes, pure virtual functions, and dynamic polymorphism. We analyze the underlying VTable and VPtr...

VTable VPtr CRTP
Section 10 #10.03
⚡ High

10.03 RPGProject

Building complete class hierarchies with character progression systems. We analyze constructor member initialization...

OOP Virtual Destructors Object Pools
Section 11 #11.01
⚡ Critical

11.01 SmartPointerFun

Deep dive into deterministic memory ownership via std::unique_ptr. Explores move semantics, zero-overhead memory...

std::unique_ptr std::make_unique Move Semantics
Section 11 #11.02
⚡ Critical

11.02 RuleOfThreeFiveZeroApp

Mastering resource management under C++11/14. We analyze the Rule of Three, the Rule of Five (move semantics), and the...

Rule of 3/5/0 Copy Ctor Move Ctor
Section 11 #11.03
⚡ Critical

11.03 MapVsUnorderedMappApp

Comparing ordered Red-Black Trees (std::map) against bucket-based Hash Tables (std::unordered_map). We explore time...

std::map std::unordered_map Red-Black Trees
Section 11 #11.04
⚡ Critical

11.04 QueueProjects

Exploring FIFO queue operations and why std::queue (backed by std::deque) is replaced in embedded firmware by bounded,...

std::queue FIFO Circular Ring Buffer
Section 11 #11.05
⚡ High

11.05 RemoveEraseIdiomApp

Understanding the separation of algorithms from containers in C++. We dissect why std::remove does not alter container...

Erase-Remove std::remove Iterator Invalidation
Section 11 #11.06
⚡ Critical

11.06 Templates

Exploring generic function and class templates. We examine compile-time monomorphization, compare zero-overhead...

Templates Generic Code Code Bloat
Section 11 #11.07
⚡ High

11.07 RulesChallenge

Hands-on implementation of a custom dynamic buffer class adhering to the Rule of Three. We inspect deep copy...

Buffer Management Deep Copy Rule of Three
Section 11 #11.08
⚡ High

11.08 AlgorithmFun

Exploring the standard algorithm library. We demonstrate why C++ templates and lambdas outperform traditional C qsort()...

std::sort std::count_if
Section 11 #11.09
⚡ Critical

11.09 STLFun1

Dissecting std::vector mechanics. We explore geometric capacity doubling, sudden heap reallocations during push_back(),...

std::vector push_back Capacity Growth
Section 11 #11.10
⚡ High

11.10 AdvancedSTLApp

Comparing non-contiguous containers (std::deque, std::list) against contiguous arrays. We examine CPU cache lines, L1...

std::deque std::list Cache Locality
Section 11 #11.11
⚡ Medium

11.11 AdvancedSTLChallengeApp

Hands-on challenge manipulating STL containers, demonstrating selection guidelines based on insertion patterns, search...

STL Containers Container Selection Performance
Section 11 #11.12
⚡ Core

11.12 CarProject

Demonstrating class encapsulation, private data invariants, and composition to model automotive subsystems.

Encapsulation Composition Object Design
Section 11 #11.13
⚡ Medium

11.13 ContactsFun

Using associative mappings for key-value pair storage, with focus on lookup mechanics and embedded ROM alternative...

std::map Key-Value Associative Lookup
Section 11 #11.14
⚡ Core

11.14 CropHybridizationSimulator

Exploring value types and operator overloading in simulation modeling.

Value Semantics Operator Overloading Copying
Section 11 #11.15
⚡ High

11.15 FriendFun

Understanding the friend keyword to grant privileged internal access to helper classes without exposing raw registers...

friend Encapsulation Hardware Drivers
Section 11 #11.16
⚡ Medium

11.16 LanguageTranslatorProject

Building dictionary lookups and evaluating Flash ROM constexpr lookup tables for embedded systems.

Dictionary std::map Flash ROM
Section 11 #11.17
⚡ High

11.17 OverloadingFun

Exploring operator overloading (+, ==, <<). We show how embedded systems use operator overloading to build type-safe...

Operator Overloading Fixed-Point Type Safety
Section 11 #11.18
⚡ High

11.18 StackFun

Understanding LIFO stack adapters. We compare data structure stacks with the hardware MCU execution stack, explore...

std::stack LIFO Call Stack
Section 11 #11.19
⚡ Core

11.19 SwapperTest

Implementing generic swap templates using reference passing without heap allocations.

Templates std::swap Pass-by-Reference
Section 12 #12.01
⚡ Critical

12.01 ArrayQueueApp

Deep dive into circular array queue data structures. We examine index wrapping using modulo arithmetic, full/empty...

ArrayQueue Ring Buffer Modulo Arithmetic
Section 12 #12.02
⚡ High

12.02 ArrayListApp

Building a custom dynamic array list implementing an abstract List interface. We analyze growth factors, amortized...

ArrayList Dynamic Array Amortized O(1)
Section 12 #12.03
⚡ High

12.03 ArrayStackApp

Implementing a bounded array stack. We explore top index manipulation, push/pop mechanics, and deterministic execution.

ArrayStack LIFO Bounded Memory
Section 12 #12.04
⚡ Medium

12.04 LinkedChainFun

Exploring explicit node pointer linking and traversing heap-allocated structures.

Node Pointers Memory Layout
Section 12 #12.05
⚡ High

12.05 LinkedListApp

Building a full linked list data structure implementing List<T>. We examine insertion/deletion at arbitrary positions,...

LinkedList Dynamic Allocation Heap Fragmentation
Section 12 #12.06
⚡ Medium

12.06 LinkedQueueProject

Implementing a node-based FIFO queue with front and rear pointers, contrasting its memory footprint with array ring...

LinkedQueue FIFO Pointer Chasing
Section 12 #12.07
⚡ Medium

12.07 LinkedStackApp

Implementing a node-based dynamic stack, analyzing push/pop pointer manipulation and cleanup.

LinkedStack LIFO Dynamic Nodes
Section 12 #12.08
⚡ High

12.08 ListStackProject

Demonstrating the Adapter design pattern by implementing a Stack interface over an underlying LinkedList.

Adapter Pattern Composition ListStack
Section 12 #12.09
⚡ Critical

12.09 TemplatedArrayStackApp

Implementing a generic templated array stack. We explore type-safe compile-time instantiations, bounded memory...

Templates ArrayStack Zero-Heap
Section 12 #12.10
⚡ Core

12.10 _for-proj12-2-files

Comparative architectural review of custom data structure implementations across performance, footprint, and...

Reference Architecture Data Structures Comparative Analysis