Welcome to My Portfolio
I'm Abdullah Alzahrani, a passionate self-taught developer. This portfolio serves as a living document of my learning journey, showcasing the projects I've built while learning foundational programming concepts and developing my skills toward becoming a back-end and eventually full-stack developer.
Tools & Technologies
C++ Console Projects
Projects are listed from newest (at top) to oldest (at bottom). Content is subject to updates.
Bank Management System
A structured OOP-based banking system that manages clients, users, transactions, and currencies with file-based storage and secure user authentication
Queue Line Management System
A console-based system that manages client queues, tickets, and services efficiently
Bank & ATM Management System
A complete banking and ATM simulation system built using structured procedural programming
Library Management System
A simple app to manage books by adding, borrowing, returning, and removing with live updates
Math Quiz Game
A logic-based quiz that generates random math questions by difficulty and operation type
Rock Paper Scissors Game
A fast-paced console game with random moves, score tracking, and multiple rounds
Utility Classes & Libraries
Projects are listed from newest (at top) to oldest (at bottom). Content is subject to updates.
Doubly Linked List Class
A template-based class for efficient doubly linked list operations with full node control and traversal support.
Date Manipulation Class
A class designed for flexible date manipulation, featuring methods for formatting, comparison, and calendar calculations.
Input Validation Class
A structured class for safe user input handling with clean methods for reading, validating, and filtering data.
String Helper Class
A class for efficient string manipulation, with functions for text analysis, formatting, and transformation.
Utility Class
A utility class that offers general helper functions for numbers, arrays, vectors, and encryption.
File Handler Library
A foundational library providing modular functions for easy data storage and structured file I/O operations.
Rock-Paper-Scissors Game
The Rock-Paper-Scissors Game is a C++ console project built to demonstrate logic, randomness, and user interaction. It uses enums, structs, and clean function design to create a full playable experience.
1. Overview
This project represents an early stage of learning C++ fundamentals. It focuses on control flow, conditions, random number generation, and console-based feedback. The player competes with the computer across multiple rounds with a clear summary at the end.
2. Game Logic
- Player selects between Stone, Paper, or Scissors.
- Computer makes a random choice using
rand()andsrand(). - Each round determines a winner or a draw based on fixed rules.
- The program tracks total wins, losses, and draws.
- A color-coded result screen appears after every round.
3. Code Structure
- Enums:
enWinnerandenGameChoicedefine possible states. - Structs:
stRoundInfoandstGameResultsstore round data and totals. - Functions: Each feature is isolated into a simple reusable function.
- Randomization:
RandomNumber()ensures fair computer choices.
4. Techniques
Several techniques were used to make the gameplay smooth and stable:
- Input Validation: Ensures correct user entries by clearing input buffers with
cin.clear()andcin.ignore(). - Random Logic: Generates unpredictable computer choices using seeded randomness.
- Console Effects: Color changes and sounds provide instant feedback for each outcome.
- Structured Design: Each block of logic is separated for readability and maintainability.
5. Screenshots
6. Learnings
Building this project improved understanding of loops, conditions, and structured programming in C++. It taught how to separate logic, apply randomization, and build interactive console programs.
7. Try The Project
Download the project as a ZIP folder and extract it. Once unpacked, you can run the program directly. Download it here.
8. Source Code
Visit the project repository on GitHub to view source code from here.
Math Quiz Game
The Math Quiz Game is an interactive console project that tests arithmetic skills through random questions. It challenges the player with different levels of difficulty and operation types while giving real-time feedback.
1. Overview
This project was created to practice problem-solving, random generation, and data handling. It allows the player to choose the number of questions, difficulty level, and operation type before starting the quiz. The game calculates results instantly and displays a final report at the end of each session.
2. Game Logic
- The player selects how many questions to answer, from 1 to 10.
- Levels include Easy, Medium, Hard, or Mix (a random combination).
- Operations include Addition, Subtraction, Multiplication, Division, or a mix of all.
- Each question is generated randomly with its correct answer stored for later comparison.
- Correct and wrong answers are tracked throughout the quiz, ending with a final score and pass/fail result.
3. Code Structure
- Structs:
sQuestionholds individual question data, andsQuizzmanages the overall session. - Enums:
enQuestionLevelandenOperationTypemake configuration simple and readable. - Functions: Small reusable functions handle question creation, user input, validation, and score calculation.
- Randomization: Questions and operations are randomized for a unique experience each time.
4. Techniques
- Validation: User inputs are checked to prevent invalid entries and ensure smooth gameplay.
- Color Feedback: Console colors change for correct and wrong answers to enhance interactivity.
- Random Generation: Uses seeded randomness with
srand()andrand()for fair variation. - Pass Criteria: The player must have more correct answers than wrong ones to pass.
5. Screenshots
6. Learnings
Creating this quiz improved understanding of control flow, struct usage, and modular programming. It reinforced concepts of function design, random number handling, and user feedback systems. The project also showed how simple math logic can become a fun interactive experience.
7. Try The Project
Download the project as a ZIP folder and extract it. Once unpacked, you can run the program directly. Download it here.
8. Source Code
Visit the project repository on GitHub to view source code from here.
Library Management System
The Library Management System is a console application for organizing books in a small virtual library. It allows users to add, display, borrow, return, and remove books with real-time status updates.
1. Overview
This project simulates a basic library system designed to manage book records using structured data. It provides a simple menu interface that lets users perform all core operations directly from the console. Each book is stored with a unique ID, title, author, category, and borrowing status.
2. Main Features
- Add Books: Register new books with a random ID, title, author name, and category.
- Display Books: Show all books with total count, borrowed status, and category information.
- Borrow and Return: Mark books as borrowed or returned while keeping the list updated.
- Remove Books: Delete books permanently from the collection.
- Categories: Supports Fiction, Science, History, Technology, and Art.
3. Code Structure
- Struct:
stBookInfostores book data including ID, title, author, category, and status. - Enums:
enOptionsandenBookCategorydefine menu choices and book types. - Functions: Each operation (add, borrow, return, remove) is handled by a dedicated function for clarity.
- Vector Container: Books are stored in a
<vector>for dynamic data handling.
4. Techniques
- Random ID Generation: Uses
rand()to assign unique IDs to new books. - Input Validation: Ensures valid menu choices and correct numeric inputs.
- Console Feedback: Color-coded output for success, errors, and general actions.
- Reusable Components: Functions are modular and can be reused in larger systems.
5. Screenshots
6. Learnings
Building this system improved understanding of data structures, vectors, and functional design. It also reinforced the importance of input validation and user interaction through console interfaces. This project bridges simple logic programming with real-world data organization.
7. Try The Project
Download the project as a ZIP folder and extract it. Once unpacked, you can run the program directly. Download it here.
8. Source Code
Visit the project repository on GitHub to view source code from here.
Bank & ATM Management System
The Bank & ATM Management System is a comprehensive console project built using structured procedural programming. It simulates a complete financial environment where users, clients, and transactions are managed through text-based data files that act as a simple database.
1. Overview
This project applies the fundamentals of procedural programming to build a fully functional banking system with an ATM simulation mode.
It includes user login, permission control, client account management, and transaction recording.
All operations read and write directly to .txt files, maintaining persistent data storage without a traditional database.
The system demonstrates a clean separation between administrative operations (Bank mode) and client-focused functionality (ATM mode).
2. System Flow
- The program starts with a secure login screen that validates user credentials stored in
Users.txt. - Depending on permissions, users can access the Bank System (for managing clients) or the ATM System (for financial operations).
- Client data, including balance and transaction history, is read from
Clients.txtandTrans.txt. - Every operation (add, withdraw, deposit, transfer) immediately updates the related text files to ensure consistency across sessions.
- The system provides clear text-based menus for navigation and real-time transaction feedback.
3. Code Structure
- Core Logic: The main source file contains modular functions for all banking and ATM operations, maintaining a structured and reusable flow.
- Input Handling:
in.hmanages validation, safe user input, and range enforcement for numeric and textual data. - String Utilities:
str.hhandles splitting, parsing, and data extraction for lines read from files. - File Database: Client, user, and transaction data are stored in
Clients.txt,Users.txt, andTrans.txt. Each record is parsed into structured vectors for in-memory processing. - Procedural Design: The system avoids classes and instead relies on cleanly separated functions, each performing a single, well-defined task (e.g. listing clients, performing deposits, checking balances).
- Permission Control: Access levels are implemented through bitwise flags that determine which menu items a user can access.
- Menu Structure: Each major section (Login, Bank Menu, ATM Menu) has its own function that routes user input to the correct feature.
4. Techniques
- Procedural Programming: Implements a clear function-based design with no object orientation, showcasing modular, readable code organization.
- Text File Database: All data persistence is achieved using
<fstream>to read and write structured text files instead of a DBMS. - Dynamic Storage: Uses
<vector>containers to temporarily hold client and transaction data during runtime for efficient lookup and updates. - Transaction Logging: Each deposit, withdrawal, and transfer is automatically recorded in
Trans.txtwith timestamps and client IDs. - Secure Login System: Validates users against stored credentials and applies access permissions based on role configuration.
- Menu Navigation: Structured text-based menus guide the user through all available actions in a logical and intuitive flow.
5. Screenshots
6. Highlights
- Demonstrates strong procedural structure using reusable modular functions.
- Implements a fully functional file-based database system using
<fstream>. - Includes a permissions system that restricts user actions based on access rights.
- Simulates real-world banking operations including balance checks, withdrawals, deposits, and fund transfers.
- Integrates ATM and Bank management logic in one cohesive program with shared data files.
7. Learnings
This project served as a comprehensive exercise in structured programming, teaching how to design large-scale systems without classes while keeping the codebase maintainable. It deepened my understanding of file I/O, data persistence, and permission systems, and helped solidify best practices for organizing procedural code in real-world applications.
8. Try The Project
Download the project as a ZIP folder and extract it. Once unpacked, you can run the program directly. Download it here.
Use the default login info: Username: Admin , Password: 1234.
9. Source Code
Visit the project repository on GitHub to view source code from here.
Queue Line Management System
The Queue Line Management System is a console project built to apply data structure and object-oriented programming concepts. It demonstrates how queues can be used in real-world scenarios to manage clients, track waiting times, and issue service tickets in a structured way.
1. Overview
This project reinforces core OOP principles such as encapsulation, inheritance, and data abstraction while implementing queue-based logic.
The system uses the clsQueueLine class to simulate real-time queue operations, where each client receives a ticket and waits to be served.
It’s a focused, single-module application that highlights how data structures can be extended through class design to solve practical problems.
2. System Flow
- The system is pre-configured with two example queues to simulate a real-world scenario: a Pay Bills Queue and an Accounts Services Queue.
- Each queue line is managed by a single
clsQueueLineinstance. - Clients are added to the queue by generating a new ticket with issue time and waiting number.
- Tickets are served in the same order they were issued, following the standard FIFO (First In, First Out) logic.
- After each service, waiting counts and average waiting times update automatically.
- The program outputs clear details for each ticket including ID, time, and position in line.
3. Code Structure
- Core Class:
clsQueueLinethe main class built over the standard<queue>container. It handles ticket creation, serving, and queue tracking while maintaining live statistics like total issued, served, and waiting clients. - Data Model: A private struct stores each ticket’s ID, issue time, and waiting count, ensuring all queue data remains organized and isolated.
- Encapsulated Logic: Core operations (create, serve, clear, print) are exposed through controlled public methods, keeping internal state protected.
- Layered Design: Each menu or screen has its own class that acts as a user interface layer, separated from the logic layer handled by
clsQueueLine. This improves structure and readability. - Performance Tracking: The system continuously updates and displays queue metrics, such as current size and average waiting time, after each service operation.
4. Techniques
- OOP Design: Encapsulation and inheritance organize queue logic and make it extendable.
- Queue Data Structure: Demonstrates practical application of FIFO principles in real-time service flow.
- Dynamic Statistics: Calculates total tickets, served clients, and average waiting time live.
- Formatted Output: Uses structured console printing to show queue data clearly and cleanly.
5. Screenshots
6. Highlights
- Applies real queue logic through a class-based structure.
- Reinforces OOP foundations including encapsulation and inheritance.
- Includes modular functions for ticket creation, serving, clearing, and printing.
- Efficiently tracks queue statistics with minimal code and clean logic.
7. Learnings
Developing this system strengthened understanding of how data structures can be extended through object-oriented design. It helped visualize how queues work in real-time service simulations and how to structure logic around reusable class methods. This project bridges theoretical OOP concepts with applied programming practice.
8. Try The Project
Download the project as a ZIP folder and extract it. Once unpacked, you can run the program directly. Download it here.
9. Source Code
Visit the project repository on GitHub to view source code from here.
Bank Management System
The Bank Management System is an upgraded and restructured version of the earlier procedural banking project. It represents a full transition to object-oriented programming, applying class-based design and modular architecture to manage clients, users, and multi-currency operations with real-time data persistence through text files.
1. Overview
This project applies every core concept of OOP — encapsulation, inheritance, abstraction, and modular class design — to simulate a real banking environment. It features a complete data management workflow where clients, employees, and currencies are all represented as structured entities stored inside text-based databases. The system ensures data consistency, role-based control, and secure operations while keeping the entire logic organized across multiple layers.
2. System Flow
- Users log in through the
clsLoginScreenusing credentials encrypted and verified byclsUtil. - Based on permission flags, they gain access to different modules: client management, transactions, user administration, or currency tools.
- Client information — including account number, balance, PIN code, and full name — is stored in
Clients.txtand can be searched, updated, or deleted through dedicated screens likeclsFindClientScreenandclsUpdateClientScreen. - User records, representing bank employees, are saved in
Users.txtand handled byclsUserandclsManageUsersMenuScreen, allowing admin-level control over staff accounts and access rights. - Login activities and transfer operations are logged in
LoginRegister.txtandTransferLog.txtfor accountability and monitoring. - The
clsCurrenciesclass manages all available currencies fromCurrencies.txt, enabling rate updates and on-the-fly currency conversions throughclsCurrencyCalculatorScreen.
3. Code Structure
- Core Classes:
clsBankClient,clsUser,clsCurrencies,clsScreen,clsDate, andclsUtil. Each one has a distinct role — clients and users represent data models, while screens handle user interactions and system logic. - Screen Layer: Over ten dedicated screen classes handle interface logic — such as
clsDepositScreen,clsTransferScreen,clsCurrencyCalculatorScreen, andclsTotalBalancesScreen. Each screen provides a focused, menu-driven experience that interacts with the backend classes. - Data Layer: Persistent storage uses text files for real-world simulation of a database. Each record is parsed into objects and saved back after modification using
<fstream>:Clients.txt— stores all client records with balances and account details.Users.txt— holds user credentials, permissions, and status flags.Currencies.txt— includes currency codes, names, and exchange rates.TransferLog.txt— tracks all fund transfers between accounts.LoginRegister.txt— logs every login attempt with timestamps and usernames.
- Utility Layer:
This layer provides supportive tools that power the entire system behind the scenes.
It includes:
clsUtil— handles encryption, random generation, and general formatting.clsString— offers advanced string manipulation and parsing utilities for data extraction and formatting.clsDateandclsPeriod— manage date calculations, time formatting, and duration handling throughout reports and logs.
4. Techniques
- Full OOP Design: Over fifteen interlinked classes demonstrating inheritance, encapsulation, and abstraction.
- Text File Database: Persistent, human-readable data storage through
<fstream>. - Encryption System: Passwords and sensitive data are encrypted and validated using
clsUtil. - Layered Architecture: Clear division between interface (screens), logic (classes), and storage (files).
- Bitwise Permissions: Access levels are defined using bitwise operations to grant or restrict user actions dynamically.
- Transaction Management: Realistic operations for deposit, withdrawal, balance check, and account-to-account transfer.
- Currency Exchange Module: Fetches and updates rates, performs conversions, and calculates exchange values instantly.
5. Screenshots
6. Highlights
- One of the largest OOP systems I’ve developed — combining multiple subsystems into one cohesive application.
- Integrates both banking and currency management under a unified, file-based data model.
- Applies strong OOP structure with reusable classes, inherited screens, and well-organized layers.
- Includes a working permissions and encryption system built from scratch.
- Represents a complete small-scale simulation of real financial software logic.
7. Learnings
Building this system solidified my understanding of class architecture, data flow, and real-world problem modeling through OOP. It taught me how to structure large-scale codebases, separate UI from logic, and use persistent file storage efficiently. The integration of the currency exchange module pushed me to handle complex data relationships and modular design. This project reflects my transition from beginner-level code to structured, scalable, maintainable development.
8. Try The Project
Download the project as a ZIP folder and extract it. Once unpacked, you can run the program directly. Download it here.
Use the default login info: Username: Admin , Password: 1234.
9. Source Code
Visit the project repository on GitHub to view source code from here.
File Handler Library
The File Handler Library is one of the first libraries I built early in my C++ journey. It focuses on clean and structured file operations, helping programs handle text-based data efficiently.
1. Overview
This library provides a simple and reusable way to manage text files through a set of modular functions.
It supports operations like creating, reading, updating, and deleting records, all organized under the
fs namespace.
The goal was to understand how persistent data can be managed with clarity and structure.
2. Core Features
- Structured Records: Converts between text lines and C++ data structures for better readability and control.
- File Management: Create, clear, copy, and print files safely using a minimal set of commands.
- Content Editing: Add, remove, or modify specific records and lines with precise file access.
- Batch Loading: Load entire files into memory as
std::vectorcontainers for efficient data manipulation. - Text Utilities: Search and erase substrings directly from file lines using smart parsing logic.
- Modular Design: Organized inside the
fsnamespace to integrate easily into larger systems.
3. Design Notes
The library is written entirely in standard C++ and uses headers such as
<fstream>, <vector>, and <string>
to manage files and data in memory.
It also includes a helper dependency str.h for splitting and parsing strings.
Each function is kept focused and independent, making the code base clean, readable, and easy to maintain.
4. Learning Reflection
Building this library taught me how to design reusable modules, handle file input/output safely, and think in terms of structured data management. It marked the early stage of developing a mindset focused on scalability, readability, and maintainable architecture.
5. Source Code
Visit the project repository on GitHub to view source code from here.
Utility Class
The clsUtil class is a general-purpose utility class written in C++ that provides a collection of practical helper functions for numbers, arrays, vectors, matrices, and encryption. It was one of the earliest and most important building blocks I developed to simplify logic across multiple small projects.
1. Overview
This class groups common operations into one accessible structure, reducing the need for repetitive code. It includes mathematical helpers, random generators, array and matrix handling, and text encryption utilities. The design follows a clean and modular style to encourage reusability in different projects.
2. Core Functionalities
- Numeric Tools: Functions for checking primes, perfect numbers, reversing digits, and frequency counting.
- Randomization: Generate random numbers, characters, words, and unique keys with a flexible enum-based system.
- Array Operations: Fill, copy, shuffle, and analyze arrays easily with a consistent interface.
- Vector Utilities: Add, print, and manage vector elements interactively.
- Matrix Operations: Sum, search, and verify data in small matrices for algorithmic learning and testing.
- Encryption & Text Handling: Simple character-based encryption and decryption for strings.
3. Design Notes
The class uses standard C++ headers like
<iostream>, <vector>, <string>, and <ctime>
to handle computations and data manipulation efficiently.
Each method is static, allowing direct access without creating class instances.
This makes clsUtil lightweight and easy to integrate into other systems.
4. Learning Reflection
Developing this class helped me learn how to organize related functionalities into one cohesive structure. It strengthened my understanding of static methods, modular programming, and efficient code reuse. It also served as an introduction to designing classes that act as general-purpose tools for larger software systems.
5. Source Code
Visit the project repository on GitHub to view source code from here.
String Helper Class
The clsString class is a comprehensive implementation for handling and transforming textual data. It focuses on practical string manipulation, text formatting, and word analysis, all structured to enhance clarity and reusability in code.
1. Overview
This class provides a complete set of methods for managing strings efficiently. It handles case conversion, word and character counting, text trimming, splitting, joining, and pattern replacement. Each function is designed with simplicity and flexibility in mind to support a wide range of text-processing needs.
2. Core Functionalities
- Word and Character Analysis: Count words, vowels, capital and small letters, and specific characters within text.
- Case Control: Convert text to uppercase, lowercase, or mixed case through structured methods.
- Text Cleaning: Remove punctuation, trim spaces, and normalize text formatting.
- Splitting and Joining: Split text into
<vector>elements or join them back with custom delimiters. - Word Replacement: Replace exact or case-insensitive words using clean and readable logic.
- String Reversal: Reverse text order while maintaining readability and structure.
3. Design Notes
The implementation relies on standard C++ headers such as
<iostream> and
<vector> for text operations and memory handling.
Most functions are declared as static to allow direct access without object creation,
ensuring faster performance and a clear, utility-focused design.
The class also uses properties for managing its internal string value conveniently.
4. Learning Reflection
Building this class improved my understanding of text processing, ASCII-level manipulation, and reusable function design. It also demonstrated how string algorithms can be organized into structured, testable components that enhance both readability and performance in C++ applications.
5. Source Code
Visit the project repository on GitHub to view source code from here.
Input Validation Class
The clsInputValidate class provides reliable tools for reading and verifying user input safely. It ensures that data entered in interactive applications is validated and formatted correctly before use.
1. Overview
This class is designed to handle user input in a structured and error-free way. It includes functions for reading strings, characters, and numbers of various types, as well as validating numeric ranges and preventing invalid input. The goal is to make interactive programs more robust and user-friendly by handling all input logic in a centralized, reusable class.
2. Core Functionalities
- String and Character Reading: Safely reads text or single characters with input buffer handling.
- Numeric Validation: Reads integers or floating-point numbers while preventing invalid entries.
- Range Enforcement: Ensures numbers fall within specific limits using templated validation methods.
- Boolean Input: Converts yes/no responses into true or false values with clear prompts.
- Template Support: Uses C++ templates for flexible input across different data types.
- Error Protection: Clears the input buffer automatically to avoid leftover or corrupted data.
3. Design Notes
The class is implemented with standard C++ headers such as
<iostream> and
<string>.
It uses templated functions to support different numeric types, ensuring reusability and consistency.
All methods are declared as static, allowing them to be called directly without object creation,
keeping the usage simple and efficient for command-line applications.
4. Learning Reflection
Building this class deepened my understanding of safe user interaction and input validation in C++. It helped me learn how to handle input streams correctly, work with templates, and design reusable static methods that keep the main application logic clean and protected from user errors.
5. Source Code
Visit the project repository on GitHub to view source code from here.
Date Manipulation Class
The clsDate class provides a complete system for handling and manipulating dates. It allows precise control over calculations, formatting, and comparison through structured and reusable methods.
1. Overview
This class is designed to simplify working with dates by providing a wide set of operations that cover creation, validation, arithmetic, and formatting. It supports converting between string and date formats, calculating time differences, determining weekdays, and printing calendar layouts. Its goal is to make date logic straightforward, readable, and accurate for any type of program.
2. Core Functionalities
- Date Creation: Initialize dates from system time, string input, or day count since the year began.
- Formatting Tools: Convert between different date string formats with customizable patterns.
- Comparisons: Check if a date is before, after, or equal to another using precise logical checks.
- Arithmetic Operations: Increase or decrease dates by days, months, years, decades, or centuries.
- Calendar Display: Print monthly or yearly calendars directly to the console in an aligned format.
- Day Calculations: Count remaining days in a week, month, or year, and calculate days between two dates.
- Validation: Ensure that a date is valid within leap-year and month-day constraints.
- Business Logic: Identify weekdays, weekends, and calculate vacation return dates excluding weekends.
3. Design Notes
The implementation uses standard headers such as
<iostream>,
<string>, and
<vector> for input and data storage.
Each function is written with static structure to allow direct access without creating objects.
The class also provides property syntax for cleaner code, and uses consistent naming for intuitive method discovery.
4. Learning Reflection
Building this class helped me understand how to handle time-based logic and calendar systems in C++. It strengthened my approach to structuring large sets of related functions into one coherent class and improved my ability to write scalable, precise algorithms that handle real-world date calculations correctly.
5. Source Code
Visit the project repository on GitHub to view source code from here.
Doubly Linked List Class
The clsDblLinkedList class is a fully custom implementation of a doubly linked list built entirely from scratch. It uses pointers to connect nodes manually, managing both Head and Tail references to provide full control over node traversal and manipulation.
1. Overview
This class was developed to understand and implement the internal structure of linked lists without relying on the STL. It supports all fundamental list operations including insertion, deletion, search, and reverse traversal. The design ensures stable memory handling by directly controlling dynamic allocation and pointer links between nodes.
2. Core Functionalities
- Manual Pointer Control: Directly manages node connections using
HeadandTailpointers. - Insertion Methods: Add new nodes at the beginning, end, or after a specific index.
- Deletion: Remove nodes safely with pointer updates to maintain list integrity.
- Traversal: Move forward and backward through nodes for flexible data access.
- Search: Locate nodes by index or value with efficient pointer-based iteration.
- Reverse Operation: Reverse the list order by swapping node links manually.
- Template Support: Works with any data type through C++ templates for reusability.
3. Design Notes
The implementation is completely custom and uses only standard headers like
<iostream> for I/O operations.
It defines a private node structure containing Next and Prev pointers for bidirectional linking.
Memory is managed manually with new and delete,
emphasizing understanding of heap allocation and object lifetime in data structures.
4. Learning Reflection
Developing this class from the ground up helped me gain deep insight into how linked lists work internally. I learned to manage pointers safely, prevent memory leaks, and implement bidirectional traversal logic. This project also improved my confidence in building complex data structures without relying on STL containers.
5. Source Code
Visit the project repository on GitHub to view source code from here.