⚙️ C++ Projects Overview

🧭 Overview

A collection of independent C++ projects, each focused on mastering a core concept of modern object-oriented programming and the C++ language. These projects progressively explore memory management, polymorphism, inheritance, templates, and the Standard Template Library (STL) — forming a solid foundation for writing efficient and maintainable C++ code.

---

🧠 Key Concepts Mastered

• Object-Oriented Programming (OOP): classes, inheritance, polymorphism, encapsulation
• Memory management and the Rule of Three / Orthodox Canonical Form
• Abstract classes, interfaces, and dynamic dispatch
• Exception handling and resource safety (RAII)
• Type casting and serialization
• Templates, function overloading, and generic programming
• STL containers, iterators, and algorithms
• Clean Makefile usage, modular compilation, and class design principles

---

⚙️ Tech Stack

Category	Tools & Standards
Language	C++98 Standard
Compiler	c++ with flags -Wall -Wextra -Werror
Build System	Makefile
Core Paradigm	Object-Oriented Programming
Libraries	Standard Library (STL introduced in Modules 08–09)
Environment	Linux/Unix command line

---

🧩 Modules Breakdown

Module 00 — Basics of C++ Syntax & Compilation

Focus: Understanding compilation, namespaces, I/O streams, and data types.
Skills Gained: Console I/O, header inclusion, compilation flags, Makefile automation.
Highlights: Practiced simple C++ programs to get familiar with std::cout, std::cin, and header organization.

---

Module 01 — Memory Allocation & Pointers

Focus: Dynamic memory management using new and delete, reference passing, and heap vs stack allocation.
Skills Gained: Mastered references, constructors, destructors, and RAII (Resource Acquisition Is Initialization).
Highlights: Built small classes demonstrating ownership semantics and the difference between copy and reference handling.

---

Module 02 — Orthodox Canonical Form

Focus: Constructors, copy assignment, destructors, and object lifecycle management.
Skills Gained: Implemented deep copies, avoided memory leaks, and reinforced the Rule of Three.
Highlights: Designed classes following canonical form, encapsulating dynamic data safely.

---

Module 03 — Inheritance & Polymorphism

Focus: Base and derived classes, virtual methods, and upcasting/downcasting behavior.
Skills Gained: Built hierarchies with virtual destructors, understood runtime polymorphism.
Highlights: Implemented parent-child relationships with overridden methods and protected attributes.

---

Module 04 — Abstract Classes & Interfaces

Focus: Pure virtual functions, interfaces, and subtype polymorphism.
Skills Gained: Designed flexible architectures through abstraction and interface-based design.
Highlights: Practiced designing APIs and class hierarchies with extensibility and maintainability in mind.

---

Module 05 — Exceptions & Error Handling

Focus: Exception safety, custom exception classes, and stack unwinding.
Skills Gained: Implemented try-catch blocks, rethrowing mechanisms, and validation layers.
Highlights: Simulated bureaucratic processes (forms and grades) using OOP and custom error handling.

---

Module 06 — Type Casting & Serialization

Focus: Static, dynamic, const, and reinterpret casts; converting scalar types and serializing objects.
Skills Gained: Controlled type conversions, pointer reinterpretation, and object identification.
Highlights: Implemented real-time type recognition and serialization logic between primitive and object types.

---

Module 07 — Templates & Generic Programming

Focus: Template functions, template classes, and type flexibility.
Skills Gained: Generalized algorithms to work with multiple data types.
Highlights: Implemented reusable container-like structures and generic utility functions.

---

Module 08 — STL Containers & Algorithms

Focus: Introduction to the Standard Template Library (STL).
Skills Gained: Used vector, list, map, and algorithms such as find, sort, and iterators.
Highlights: Reimplemented basic algorithms using STL containers and iterators, improving performance and code clarity.

---

Module 09 — Advanced STL Applications

Focus: Complex projects integrating STL containers, parsing, and algorithmic logic.
Skills Gained: Combined multiple STL components in problem-solving contexts.
Highlights: Implemented Bitcoin Exchange, Reverse Polish Notation, and Merge-Insertion Sort (PmergeMe) to apply algorithms in practical systems.

---

🧰 Build & Run

# Compile the project
make

# Run the executable
./<executable_name>

# Remove object files
make clean

# Remove all compiled files and executables
make fclean

# Rebuild the project from scratch
make re

🧠 This Makefile follows the C++98 standard with strict warnings enabled (-Wall -Wextra -Werror). It automatically compiles all source files, manages dependencies, and ensures a clean build environment for each run.

---

🎯 Outcomes

• Developed a strong command of C++ core principles and OOP design.
• Gained the ability to write robust, memory-safe, and modular code.
• Learned to balance abstraction and performance using templates and STL.
• Built an understanding of real-world C++ software architecture and compiler-level control.
• Strengthened analytical problem-solving through incremental and peer-reviewed development.

---

💡 These projects collectively form a foundation for professional-level C++ development, emphasizing correctness, clarity, and control over low-level mechanics while preparing for modern practices (C++11 and beyond).