This C++ project implements a priority queue-based system for managing widget orders. It's designed to simulate a real-world order processing system where orders are prioritized based on certain criteria.
- Features
- System Requirements
- Installation and Setup
- Usage
- Technical Implementation
- Contributing
- Contact Information
- Priority Queue Implementation: Efficiently manages orders based on priority.
- Order Processing: Simulates daily order processing in a business environment.
- User-Friendly Interface: Provides an easy-to-navigate menu for placing and viewing orders.
- Operating System: Windows, Linux, or MacOS.
- Compiler: C++ compiler (GCC, Clang, MSVC) with C++11 support or higher.
- Clone the repository:
git clone [repository-url](https://github.com/danieldotwav/PriorityQueue)]
. - Navigate to the project directory.
- Compile the project:
g++ -o priorityQueue Source.cpp
- Run the compiled executable:
./priorityQueue
.
The main menu offers options to place a new order, view existing orders, and process daily orders.
- Select 'Place Order' from the main menu.
- Follow the prompts to specify order details.
- The order is then added to the priority queue.
- Select 'Process Orders' to simulate the processing of daily orders.
- Orders will be processed based on their priority.
This section outlines the sophisticated C++ concepts and techniques employed in the development of the priority queue-based widget ordering system.
- Custom Priority Queue Implementation: The project features a custom priority queue, specifically tailored for order management. This demonstrates an understanding of data structure design and application.
- Heap Data Structure: Utilizes a heap data structure to efficiently manage the priority queue, showcasing knowledge in advanced data structures.
- Classes and Objects: The system is designed using object-oriented principles, with classes like
Order
andPriorityQueue
representing different entities and functionalities. - Operator Overloading: Implements operator overloading (e.g.,
<
and<=
in theOrder
class) to compare orders based on rush status, demonstrating an understanding of C++'s powerful object-oriented features.
- Robust Exception Handling: Implements custom exception classes (
FullPQ
andEmptyPQ
) to manage exceptional situations in the priority queue operations, ensuring the robustness of the system.
- Use of Standard Template Library (STL): Although the core data structures are custom-implemented, the code reflects an understanding of the STL, evident in the usage of standard headers and namespaces.
- Dynamic Memory Management: The design likely involves dynamic memory management, crucial for handling data structures like heaps and priority queues.
- Efficient Algorithms: Implements efficient algorithms for re-heapifying the heap (
reheapUp
andreheapDown
), crucial for maintaining the heap property of the priority queue.
- Modular Code Design: The project is structured into multiple header and source files, each serving a distinct purpose, which is a good practice for maintaining code modularity and readability.
Contributions to this project are welcome. Please follow the standard fork-and-pull request workflow. Make sure to adhere to coding standards and add tests for new features.
For any queries or support related to this project, please contact:
- Developer: [Daniel Rivas]
- GitHub Profile: [github.com/danieldotwav]