Question

Is this correct?:

std::vector<Enemy*> enemies;
enemies.push_back(new Enemy());

Enemy* enemy = enemies[0];
enemies.erase(enemies.begin() + 0);
delete enemy;

Answer 1

It works, yes, but it’s not an ideal approach.

Firstly, adding 0 is just noise, you can remove that. But even better, just use pop_front(). Also, no need for the intermediate step, you can delete before removing.

But std::vector isn’t good as popping from the front, especially if it’s large (because the remaining elements need to be shifted to fill the void). If you don’t need contiguous memory, use a std::deque instead. Or, if order doesn’t matter, you can use something like this:

template <typename T, typename A>
void unordered_pop_front(std::vector<T, A>& vec)
{
    using std::swap;
    swap(vec.front(), vec.back()); // constant time

    vec.pop_back(); // constant time
}

It swaps the front element with the back element, then pops it off. Of course, order is not retained.

The other problem is with your approach to memory management. Anytime you have explicit clean up code, you’ve done something wrong. It should be done automatically.

Use either Boost’s ptr_vector, or a std::vector of smart pointers. (Note: do not use std::auto_ptr in a container, it’s broken in this regard.) For a quick smart pointer suggestion, use either std::unique_ptr (if your compiler supports C++0x), or std::/boost::shared_ptr.