Ошибка: нет доступа к полю класса

#include <iostream>
#include <map>
#include <string>
#include <typeindex>
#include <vector>
#include <set>
#include <type_traits>
#include <algorithm>
 
using namespace std;
 
class Component
{
protected:
    size_t componentID_{ 0 };
public:
    size_t getComponentID() {
        return componentID_;
    }
    virtual ~Component() = default;
};
 
class Entity
{
private:
    std::map<size_t, Component*> components_;
    std::string entityName_{};
    size_t idEntity_{ 0 };
public:
 
    //TODO: Добавить activate/deactivate
 
    void setEntityName(const std::string entityName)
    {
        entityName_ = entityName;
    }
 
    const std::string getEntityName() {
        return entityName_;
    }
 
    void setID(const size_t id)
    {
        idEntity_ = id;
    }
 
    const size_t getID()
    {
        return idEntity_;
    }
 
    const bool containComponent(size_t componentID) 
    {
        for (auto component : components_) {
            if (component.second->getComponentID() == componentID) {
                return true;
            }
        }
        return false;
    }
 
    std::vector<size_t> getContainsComponentsID() const {
        std::vector<size_t> resultVector;
        std::transform(components_.cbegin(), components_.cend(), std::back_inserter(resultVector), [](auto&& arg) { return arg.first; });
        return resultVector;
    }
 
    Component* getComponent(size_t componentID)
    {
        for (auto component : components_) {
            if (component.second->getComponentID() == componentID) {
                auto poiner = components_.at(componentID);
                return poiner;
            }
        }
    }
 
    template<typename TComponent>
    void addComponent(TComponent* addingComponent)
    {
        components_[addingComponent->getComponentID()] = addingComponent;
    }
 
    template<typename TComponent>
    void createComponent()
    {
        TComponent* buff = new TComponent();
        components_[buff->getComponentID()] = buff;
    }
    
    void removeComponent(size_t removingID) 
    {
        components_.erase(removingID);
    }
 
    const size_t howManyComponents() {
        return components_.size();
    }
 
    void removeAllComponents()
    {
        components_.clear();
    }
 
    virtual ~Entity() {
        removeAllComponents();
    };
 
};
 
class System
{
private:
    std::set<size_t> processedComponents_;
    size_t idSystem_{ 0 };
public:
 
    void setID(size_t value) 
    {
        idSystem_ = value;
    }
 
    const size_t getID() 
    {
        return idSystem_;
    }
 
    void addProcessedComponent(size_t addingComponentID)
    {
        processedComponents_.insert(addingComponentID);
    }
 
    void removeProcessedComponent(size_t removingComponentID)
    {
        processedComponents_.erase(removingComponentID);
    }
 
    const bool containProcessedComponent(size_t componentID)
    {
        return processedComponents_.count(componentID) != 0;
    }
 
    std::vector<size_t> getProcessedComponentsID() const {
        std::vector<size_t> resultVector(processedComponents_.begin(), processedComponents_.end());
        return resultVector;
    }
 
    ~System() {
        processedComponents_.clear();
    };
 
    
    virtual void updateSystem(Entity*) {};
};
 
class World
{
private:
    std::map<size_t, System*> systems_;
    std::map<size_t, Entity*> entities_;
    std::multimap<size_t, size_t> pairSysIDEntID_;
    size_t lastEntityID_{ 0 };
public:
 
    //TODO: Добавить activate/deactivate
 
    size_t getLastEntityID()
    {
        return lastEntityID_;
    }
 
    template <typename TEntity>
    void addEntity(TEntity* addingEntity)
    {
        if (addingEntity->getID() == (size_t)0)
        {
            addingEntity->setID(++lastEntityID_);
        }
        else {
            lastEntityID_ = addingEntity->getID();
        }
        entities_[addingEntity->getID()]=addingEntity;
    }
 
    template <typename TEntity>
    void createEntity()
    {
        TEntity* buff = new TEntity();
        entities_[++lastEntityID_]= buff;
    }
 
    //template <typename TEntity>
    void purgeEntity(size_t purgingEntityID)
    {
        size_t keyOfPurgingEntity(0);
        for (auto it = entities_.begin(); it!=entities_.end(); ++it)
        {
            if (it->second->getID() == purgingEntityID) {
                keyOfPurgingEntity = it->first;
                break;
            }
        }
        entities_.erase(keyOfPurgingEntity);
    }
 
    void clearEntities() {
        entities_.clear();
    }
 
    template <typename TSystem>
    void addSystem(TSystem* addingSystem)
    {
        systems_[addingSystem->getID()] = addingSystem;
    }
 
    template <typename TSystem>
    void createSystem()
    {
        TSystem* newSystem = new TSystem();
        systems_[newSystem->getID()] = newSystem;
    }
 
    template<typename TSystem>
    TSystem* getSystem(size_t gettingSystemID) const {
        auto pointer = systems_.at(gettingSystemID);
        return pointer;
    }
 
 
    template<typename TSystem>
    void purgeSystem(size_t purgingSystemID)
    {
        systems_.erase(purgingSystemID);
    }
 
 
    void updateWorldList()
    {
        for (auto it = systems_.begin(); it != systems_.end(); ++it)
        {
            std::vector<size_t> componentsInsideSystem = it->second->getProcessedComponentsID();
            for (auto jt = entities_.begin(); jt != entities_.end(); ++jt)
            {
                bool containsAll = true;
                for (size_t i = 0; i < componentsInsideSystem.size(); i++)
                {
                    if (!jt->second->containComponent(componentsInsideSystem[i])) {
                        containsAll = false;
                    }
                }
 
                if (containsAll) 
                {
                    pairSysIDEntID_.insert(std::pair<size_t, size_t>(it->first, jt->first));
                }
 
            }
        }
    }
 
    void refreshWorld()
    {
        for (auto it = pairSysIDEntID_.begin(); it != pairSysIDEntID_.end(); ++it)
        {
            systems_.at(it->first)->updateSystem(entities_.at(it->second));
        }
    }
 
    void clearWorld() {
        for (auto& systems : systems_) {
            systems.second->~System();
        }
        entities_.clear();
        systems_.clear();
    }
 
    ~World() {
        clearWorld();
    };
};
 
 
/*TEST*/
 
class ComponentA : public Component {
public:
    int a{0};
    ComponentA() {
        componentID_ = 1;
    }
};
 
class ComponentB : public Component {
public:
    int b{ 0 };
    ComponentB() {
        componentID_ = 2;
    }
};
 
class FirstEntity : public Entity {
public:
    FirstEntity() {
        setEntityName("First");
        //addComponent(new ComponentA);
    }
};
 
class PrimarySystem : public System {
public:
    PrimarySystem() {
        setID(1);
        addProcessedComponent(1);
    }
 
    void updateSystem(Entity* ent) override{
        auto comp = ent->getComponent(1);
        comp++;
    }
};
 
int main()
{
    World* world = new World();
    PrimarySystem* sys = new PrimarySystem();
    FirstEntity* ent = new FirstEntity();
    ent->createComponent<ComponentA>();
    ent->createComponent<ComponentB>();
    world->addSystem(sys);
    world->addEntity(ent);
    world->updateWorldList();
 
    world->refreshWorld();
 
    system("pause");
    delete ent;
    delete sys;
    delete world;
    
    
    return 0;
}

public:
    int a{0};

class PrimarySystem : public System {
public:
    PrimarySystem() {
        setID(1);
        addProcessedComponent(1);
    }
 
    void updateSystem(Entity* ent) override{
        auto comp = ent->getComponent(1);
        comp++;
    }
};

Component* getComponent(size_t componentID)
    {
        for (auto component : components_) {
            if (component.second->getComponentID() == componentID) {
                auto poiner = components_.at(componentID);
                return poiner;
            }
        }
       // <---- отсутствует return
    }

    void clearWorld() {
        for (auto& systems : systems_) {
            systems.second->~System(); // <---???
        }
        entities_.clear();
        systems_.clear();
    }