Advanced OOP Mastery Project

Your Task

Design and implement a Smart Memory Pool System with the following components:

• MemoryPool<T> - Template class for pooled allocation (7.1)
• Custom Exceptions - PoolExhaustedException, InvalidOperationException (7.2)
• SmartHandle<T> - Move-only RAII wrapper with move semantics (7.3)
• PoolManager - Singleton managing multiple pools (7.4)
• MemoryStats - Observer pattern for allocation tracking (7.4)
• Operator Overloading - For intuitive handle dereferencing and comparison (7.5)

You will create TWO test data files to validate your memory pool system. Create these files exactly as shown below:

File 1: test_objects.h (Test Object Definitions)

// Test classes for memory pool validation
#ifndef TEST_OBJECTS_H
#define TEST_OBJECTS_H

#include <string>
#include <iostream>

// Simple POD-like object for basic testing
struct GameObject {
    int id;
    float x, y, z;
    std::string name;
    
    GameObject(int id = 0, float x = 0.0f, float y = 0.0f, float z = 0.0f, 
               const std::string& name = "Object")
        : id(id), x(x), y(y), z(z), name(name) {
        std::cout << "GameObject " << id << " constructed\n";
    }
    
    ~GameObject() {
        std::cout << "GameObject " << id << " destroyed\n";
    }
};

// Complex object with resource management
class ParticleEffect {
private:
    int* data;
    size_t size;
public:
    int effectId;
    
    ParticleEffect(int id, size_t count) 
        : effectId(id), size(count), data(new int[count]) {
        std::cout << "ParticleEffect " << id << " created (" << count << " particles)\n";
    }
    
    ~ParticleEffect() {
        delete[] data;
        std::cout << "ParticleEffect " << effectId << " destroyed\n";
    }
    
    // Move semantics required
    ParticleEffect(ParticleEffect&& other) noexcept 
        : effectId(other.effectId), size(other.size), data(other.data) {
        other.data = nullptr;
        other.size = 0;
    }
    
    ParticleEffect& operator=(ParticleEffect&& other) noexcept {
        if (this != &other) {
            delete[] data;
            data = other.data;
            size = other.size;
            effectId = other.effectId;
            other.data = nullptr;
            other.size = 0;
        }
        return *this;
    }
    
    // Delete copy operations
    ParticleEffect(const ParticleEffect&) = delete;
    ParticleEffect& operator=(const ParticleEffect&) = delete;
};

#endif // TEST_OBJECTS_H

File 2: test_scenarios.cpp (Test Cases)

// Comprehensive test scenarios for memory pool system
#include "MemoryPool.h"
#include "SmartHandle.h"
#include "PoolManager.h"
#include "test_objects.h"
#include <iostream>
#include <vector>

void testBasicAllocation() {
    std::cout << "\n=== Test 1: Basic Allocation ===";
    MemoryPool<GameObject> pool(10);
    
    auto obj1 = pool.allocate(1, 10.0f, 20.0f, 30.0f, "Player");
    auto obj2 = pool.allocate(2, 5.0f, 15.0f, 25.0f, "Enemy");
    
    std::cout << "Allocated: " << pool.getAllocated() << "/" << pool.getCapacity();
    
    pool.deallocate(obj1);
    pool.deallocate(obj2);
}

void testPoolExhaustion() {
    std::cout << "\n=== Test 2: Pool Exhaustion ===";
    MemoryPool<GameObject> pool(3);
    std::vector<GameObject*> objects;
    
    try {
        for (int i = 0; i < 5; i++) {  // Try to allocate more than capacity
            objects.push_back(pool.allocate(i, 0, 0, 0, "Test"));
        }
    } catch (const PoolExhaustedException& e) {
        std::cout << "Caught expected exception: " << e.what();
    }
    
    for (auto obj : objects) {
        pool.deallocate(obj);
    }
}

void testSmartHandles() {
    std::cout << "\n=== Test 3: RAII SmartHandle ===";
    MemoryPool<ParticleEffect> pool(5);
    
    {
        SmartHandle<ParticleEffect> handle1(&pool.allocate(1, 1000), &pool);
        SmartHandle<ParticleEffect> handle2 = std::move(handle1);  // Test move
        
        std::cout << "Effect ID: " << handle2->effectId;
        // Automatic deallocation when handle2 goes out of scope
    }
    
    std::cout << "After scope exit, available: " << pool.getAvailable();
}

void testSingletonManager() {
    std::cout << "\n=== Test 4: Singleton PoolManager ===";
    auto& manager = PoolManager::getInstance();
    
    auto& goPool = manager.getPool<GameObject>(20);
    auto& pePool = manager.getPool<ParticleEffect>(10);
    
    auto go = goPool.allocate(100, 1, 2, 3, "Managed");
    
    manager.printAllStats();
    
    goPool.deallocate(go);
}

int main() {
    testBasicAllocation();
    testPoolExhaustion();
    testSmartHandles();
    testSingletonManager();
    return 0;
}

Implement ALL of the following components. Each requirement maps to specific Module 7 topics.

// Example test case structure:
struct GameObject {
    int id;
    float x, y;
    GameObject(int i, float px, float py) : id(i), x(px), y(py) {}
};

int main() {
    auto& manager = PoolManager::getInstance();
    auto& pool = manager.getPool<GameObject>(10);
    
    // Attach observer
    auto stats = std::make_unique<MemoryStats>();
    pool.addObserver(std::move(stats));
    
    try {
        // Allocate with perfect forwarding
        auto handle = pool.allocate(1, 10.0f, 20.0f);
        
        // Use operators
        if (handle) {
            std::cout << "Object ID: " << handle->id << std::endl;
            (*handle).x += 5.0f;
        }
        
        // Move semantics
        auto handle2 = std::move(handle);
        // handle is now empty
        
    } catch (const PoolExhaustedException& e) {
        std::cerr << "Pool exhausted: " << e.what() << std::endl;
    }
    
    manager.printAllStats();
    return 0;
}

Create a public GitHub repository with the exact name shown below:

Required File Structure

smart-memory-pool-cpp/
├── include/
│   ├── MemoryPool.hpp         # Template class definition
│   ├── SmartHandle.hpp        # RAII handle with operators
│   ├── PoolManager.hpp        # Singleton manager
│   ├── MemoryExceptions.hpp   # Custom exception classes
│   └── MemoryObserver.hpp     # Observer interface + MemoryStats
├── src/
│   ├── PoolManager.cpp        # Singleton implementation
│   └── main.cpp               # Comprehensive test cases
├── CMakeLists.txt             # CMake build configuration
├── Makefile                   # Alternative: Makefile (if not using CMake)
├── README.md                  # REQUIRED - see contents below
└── docs/
    └── design.md              # Optional: Design decisions document

# Using g++
g++ -std=c++17 -Wall -Wextra -O2 -Iinclude src/*.cpp -o memory_pool_test

# OR using CMake
mkdir build && cd build
cmake .. && make

Your assignment will be graded on the following criteria (Total: 300 points):