написание общего пула объектов на C ++

Для хобби-проекта Моя цель – разработать и реализовать универсальную систему для объединения произвольного класса объектов. Я пробовал реализовать это с помощью шаблонов. Этот пул должен поддерживать 4 действия: «Создать пул» «Выделить объект из этого пула» «Освободить объект из этого пула» «Уничтожить этот пул» Для простоты многопоточность отсутствует.

  1. Если мне нужно объединить классы, подобные этому примеру, как мне это сделать?
typedef char            ByteType;
typedef void*           PointerType;
typedef char            FixedStringType[256];

// A basic struct
struct Point
{
    int x, y, z;
};
  1. Кто-нибудь может поделиться своими мыслями / отзывами об ошибках и способах улучшения этого кода?
//ObjectPool.h
#pragma once
#include <vector>
#include <iostream>

const int g_MaxNumberOfObjectsInPool = 2;

template<typename T>
class DefaultAllocator {
public:
    T* operator()() {
        return new T{};
    }
    void operator()(T* p) {
        delete p;
    }
    void reset() {
        std::cout << "reset function called from default allocator" << std::endl;
    }
};

template<typename T, typename AllocatorT=DefaultAllocator<T>>
class ObjectPool
{
    struct ObjectInfo {
        bool isInUse{};
        T* ptrObject{};
    };
    static inline std::vector<ObjectInfo> poolObjects{};
    static inline AllocatorT allocator{};
public:
    static T* getObject() {
        for (auto& currObj : poolObjects) {
            if (!currObj.isInUse) {
                currObj.isInUse = true;
                std::cout << "Existing Object returned" << std::endl;
                return currObj.ptrObject;
            }
        }

        if (poolObjects.size() == g_MaxNumberOfObjectsInPool) {
            std::cout << "Pool is full " << std::endl;
            return nullptr;
        }

        std::cout << "Creating a new object" << std::endl;
        //auto newObj = new T{};
        auto newObj = allocator();
        poolObjects.push_back({ true, newObj });        
        return newObj;
    }

    static void releaseObject(T* ptrSo) {
        for (auto& currObj : poolObjects) {
            if (currObj.ptrObject == ptrSo) {
                currObj.isInUse = false;
                return;
            }
        }
    }

    static void destroy() {
        for (auto& currObj : poolObjects) {
            if (currObj.isInUse) {
                std::cout << "WARNING! this object is still in use" << std::endl;
            }
            allocator(currObj.ptrObject);
        }
        allocator.reset();
        poolObjects.clear();
    }
};

Основной файл выглядит так:

#include "ObjectPool.h"
#include <iostream>

class PrivateClass {
    PrivateClass() {

    }
public:
    void func() {

    }
    friend class PrivateAllocator;
};

class PrivateAllocator {
public:
    PrivateClass* operator()() {
        return new PrivateClass{};
    }
    void operator()(PrivateClass* p) {
        delete p;
    }
    void reset() {
        std::cout << "reset function called" << std::endl;
    }
};

int main() {
    using integer = ObjectPool<int>;
    auto int1 = integer::getObject();
    auto int2 = integer::getObject();
    auto int3 = integer::getObject();

    integer::releaseObject(int1);
    auto int4 = integer::getObject();
    integer::destroy();
    return 0;
}

0

Добавить комментарий

Ваш адрес email не будет опубликован. Обязательные поля помечены *