Pasted

#pragma once
#include <cassert>
#include <array>
#include "iPoolable.h" //see below
 
//This class borrows liberally from Robert Nystroms excellent ObjectPool
    //http://gameprogrammingpatterns.com/object-pool.html
template<class T, size_t POOL_SIZE = 32>
class Pool{ 
    static_assert(std::is_base_of<iPoolable, T>::value, "Type must implement iPoolable!");
    mutable iPoolable* _head = nullptr; //linked list of unused objects
    std::array<T, POOL_SIZE> _objects;
public:
    Pool(){             
        _head = &_objects[0];               
        for(size_t i = 0; i < POOL_SIZE - 1; ++i){ // Each object points to the next.   
            _objects[i].setNext(&_objects[i + 1]);          
        }       
        _objects[POOL_SIZE - 1].setNext(nullptr); // The last one terminates the list.      
    }
    void recycle(T* object) const noexcept {
        assert(object != nullptr);
        object->onReturnToPool(); //notify the object
        object->setNext(_head); //add the object to front of the list
        _head = object; 
    }
    T* getNext() const noexcept{
        assert(_head != nullptr); // Make sure the pool isn't exhausted.                
        T* nextObject = static_cast<T*>(_head); //get the head of the list
        _head = nextObject->getNext();  // Update the head of the list  
        nextObject->onTakenFromPool(); //notify the object
        return nextObject;
    }       
    template<typename Function>
    void apply(Function f) {        
        std::for_each(_objects.begin(), _objects.end(), f);     
    }   
    ~Pool(){
        //give objects a chance to clean up. (onReturnToPool must be noexcept!)
        std::for_each(_objects.begin(), _objects.end(), std::mem_fn(&T::onReturnToPool));           
    }
    size_t static constexpr size() noexcept { return POOL_SIZE; }   
}; //end Pool.h
 
//iPoolable.h
#pragma once
class iPoolable{
public: 
    virtual iPoolable* getNext() const noexcept = 0;
    virtual void setNext(iPoolable* next) noexcept = 0; 
    
    //Optional: release resource handles, stop timers, clean up.
    virtual void onReturnToPool() noexcept {}; 
    
    //Optional: re-aquire resources, start timers, re-initialize members. 
    virtual void onTakenFromPool() noexcept {}; 
    
    virtual ~iPoolable(){};
};
 
//Poolable.h concrete class
#pragma once
#include "iPoolable.h"
class Poolable : public iPoolable{
    iPoolable* _next = nullptr;
public: 
    void setNext(iPoolable* next) noexcept override{
        _next = next;
    }
    iPoolable* getNext() const noexcept override{
        return _next;
    }       
    virtual ~Poolable(){
        _next = nullptr;
    }   
};
 
//Vector2D.h iPoolable implementation
template<class T = float>
class Vector2D : public iPoolable{
public:     
    union{ 
        struct{
            T x;
            T y;
        }; //struct of 2 float = 8 bytes        
        iPoolable* _next; //pointer = 8 bytes
    }; //union total = 8 bytes
    
    iPoolable* getNext() const noexcept override { return _next; }
    void setNext(iPoolable* next) noexcept override { _next = next; }
 
    /* ... Vector2D interface ... */
};