Object pooling in game using a small coding example c++

When its comes to gaming either you are using unity or cocos2dx or unreal or godot or any other engine you need a object pool specially when you dealing with mobile and low hardware device because they have memory constraint. lets take a example of endless game where there is 100 of types of object that moves from either left to right or in 3d far to close using camera so one idea is that you can create graphic at runtime and remove its when its out of the screen but every time a new graphic created a new memory allocation happen and creating two many graphics at runtime can reduce frame rate and increase memory usage,

so its deal with it

1. create a object pool for example a c++ example

where bullet class and boom class can used same pool class and we can create two separate pool and each pool can hold 100 bombs and 100 bullet so when bomb or bullet out of the screen we can send it back to the pool.

2. so you are holding 200 instance at the same time and when they are not in use send them back to the pool and when they are in use get them from the pool so no new instance would be created,

#include <iostream>

#include <vector>

#include <list>

#include <queue>

#include <deque>

#include <algorithm>

#include <functional>

using namespace std;

//bullet class is a simple class which store bullet and its properties

class Bullet

{

private:

    string name;

public:

    Bullet(){};

    ~Bullet(){};

    string getName()

    {

        return  name;

    };

    void setName(string __name)

    {

        name=__name;

    }

};

//boob class stores boomb and its properties

class Boomb

{

private:

    string name;

public:

    Boomb(){};

    ~Boomb(){};

    string getName()

    {

        return  name;

    };

    void setName(string __name)

    {

        name=__name;

    }

};

//pool manager holds all pool items

template<class T>

class PoolManager

{

    private:

        deque<T*> poolQueue;

    public:

        //create a pool

        PoolManager(int size,string name)

        {

            for(int i=0;i!=size;i++)

            {

                T *t=new T();

                t->setName(name+to_string(i));

                poolQueue.push_back(t);

            }

        }

        ~PoolManager(){

            cout<<"pool is destroyed"<<endl;

        };

        deque<T*> getPoolItems()

        {

            return poolQueue;

        }

        //get items from the front of the pool

        vector<T*> getItemsFromFront(int size)

        {

            if( size>poolQueue.size() ) {

                throw "think again";

            }

            vector<T*> newItems;

            for(int i=0;i<=size;i++)

            {

                

                newItems.push_back(poolQueue.front());

                poolQueue.pop_front();

            }

            return  newItems;

        }

        //get items from the back

        vector<T*> getItemsFromBack(int size)

        {

            if( size>poolQueue.size() ) {

                throw "think again";

            }

            vector<T*> newItems;

            for(int i=0;i<=size;i++)

            {

                

                newItems.push_back(poolQueue.back());

                poolQueue.pop_back();

            }

            return  newItems;

        }

        //get pool size

        int poolSize()

        {

            return  poolQueue.size();

        }

        //get back to pool form backwards

        void backToPool(T *item)

        {

            poolQueue.push_back(item);

        }

        //get back to pool from front

        void frontToPool(T *item)

        {

             poolQueue.push_front(item);

        }

        

};