C++ Object management/deletion

If performance is an issue, you might wanna use a design method/pattern called Object pooling. What this method/pattern actually means is that you, at the start-up of the game/level/scene, fill a container (an std::vector, an std::list etc) with a fixed number of objects, bullets in your case. When a bullet is supposed to be shot in the game, the code retrieves a bullet from the container, marks it as used, moves it across the screen, renders it and whenever it should be destroyed (at collision with ground, walls, characters etc), stop rendering it and then finally mark it as free so the code knows it's ok to pick that bullet from the container later, for later usage. At the game/level/scene shutdown, the bullets are destroyed. By using this method/pattern, no bullets are created and/or destroyed during run-time.

I have added some example code below.

#include <vector>

// Bullet object
struct SBullet
{
    Vector2D    Position;
    float       Speed;
    float       Damage;
    bool        InUse;
};

typedef std::vector<SBullet*> BulletVector;

// Will be filled at the startup of the game/level/scene and destroyed/cleared at game/level/scene shutdown
BulletVector Bullets;
Bullets.clear();

// Will be filled with bullet pointers during run-time
BulletVector ActiveBullets;
ActiveBullets.clear();

int main()
{
    // Fill the bullet vector with bullets
    for(unsigned int i = 0; i < 128; ++i)
    {
        SBullet* pBullet = new SBullet;

        pBullet->Position   = Vector2D(0.0f, 0.0f);
        pBullet->Speed      = 16.0f;
        pBullet->Damage     = 2.0f;
        pBullet->InUse      = false;

        Bullets.push_back(pBullet);
    }

    While(Running)
    {
        Update();
        Render();
    }

    // Destroy the bullet vector
    BulletVector::const_iterator ItBeg = Bullets.begin();
    BulletVector::const_iterator ItEnd = Bullets.end();

    for(; ItBeg != ItEnd; ++ItBeg)
    {
        delete (*ItBeg);
    }

    Bullets.clear();
}

void Update()
{
    // Mouse button has been pressed so it's time to add a free bullet into the active bullets vector
    if(InputHandler.MouseButtonClicked)
    {
        SBullet* pBullet = RetrieveFreeBullet();

        if(pBullet)
        {
            pBullet->Position   = pPlayer->GetPosition(); 
            pBullet->InUse      = true;

            ActiveBullets.push_back(pBullet);
        }
    }

    unsigned int NumBullets = ActiveBullets.size();
    unsigned int Index      = 0;

    while(Index < NumBullets)
    {
        SBullet* pBullet = ActiveBullets[Index];

        MoveBulletAcrossScreen(pBullet);

        /*
        The bullet has collided with an enemy, mark it as free, remove it from the active bullets vector and maybe render some explosion/particles etc
        Removing the bullet from the active bullets vector wont destroy the actual bullet, only remove the actual pointer from the vector
        */
        if(CollisionCheck(pBullet, pEnemy))
        {
            pEnemy.ReduceHealth(pBullet->Damage);

            pBullet->Position   = Vector2D(0.0f, 0.0f);
            pBullet->InUse      = false;

            SBullet* pTemp = ActiveBullets[Index];

            /*
            Swap the current bullet's and the last bullet's container position
            It's better to remove an object in the end of the vector since the rest of the objects after won't have to be moved back in the vector to fill up the empty space (which is costly)
            */
            ActiveBullets[Index] = ActiveBullets[NumBullets - 1];
            ActiveBullets[NumBullets - 1] = pTemp;

            ActiveBullets.pop_back();

            --NumBullets;
        }

        // The bullet has collided with some ground - the same procedure as above to remove the bullet
        else if(CollisionCheck(pBullet, pGround))
        {
            pBullet->Position   = Vector2D(0.0f, 0.0f);
            pBullet->InUse      = false;

            SBullet* pTemp = ActiveBullets[Index];

            ActiveBullets[Index] = ActiveBullets[NumBullets - 1];
            ActiveBullets[NumBullets - 1] = pTemp;

            ActiveBullets.pop_back();

            --NumBullets;
        }

        else
            ++Index;
    }
}

void Render()
{
    BulletVector::const_iterator ItBeg = ActiveBullets.begin();
    BulletVector::const_iterator ItEnd = ActiveBullets.end();

    for(; ItBeg != ItEnd; ++ItBeg)
    {
        RenderSprite((*ItBeg), pBulletSprite);
    }
}

SBullet* RetrieveFreeBullet()
{
    // Might wanna have a variable containing the last used index into the bullet vector for faster returning of a bullet

    BulletVector::const_iterator ItBeg = Bullets.begin();
    BulletVector::const_iterator ItEnd = Bullets.end();

    for(; ItBeg != ItEnd; ++ItBeg)
    {
        if((*ItBeg)->InUse)
            continue;

        return (*ItBeg);
    }

    // No free bullet available, might wanna return the bullet at the start of the vector instead of nullptr so that a valid bullet is always returned
    return nullptr;
}