Untitled

#include <iostream>
#include <algorithm>

template<size_t VALUE_SIZE, size_t POOL_CAPACITY>
struct memory_pool {

    std::size_t p = 0;
    std::size_t flags[POOL_CAPACITY];
    std::byte pool[POOL_CAPACITY*VALUE_SIZE];

    memory_pool() {
        std::fill(std::begin(flags), std::end(flags), 0);    // 0 = free, 1 = used   ( can memset )
    }

    std::byte* acquire() {
        std::size_t i = 0;
        while (i < POOL_CAPACITY) {
            if (flags[i] == 0) {
                break;
            }
            i++;
        }

        if (i == POOL_CAPACITY) {
            return nullptr;
        }
        flags[i] = 1;
        return &pool[i];
    }

    void release(std::byte* at) {
        std::byte* end = &pool[POOL_CAPACITY];
        std::byte* begin = &pool[0];
        if (at < end && at >= begin) {
            std::size_t i = ((end - at)/VALUE_SIZE);
            if (flags[i] == 0) {
                throw std::runtime_error("Double release detected");
            }
            flags[i] = 0;
        } else {
            throw std::runtime_error("Input pointer out of range");
        }
    }
};


int main() {
    //instance:
    memory_pool<sizeof(int), 200> twohundred_ints;
    return 0;
}