C ++向量动态内存释放/删除

Question

When I try and delete dynamic memory elements of a dynamic vector of objects, I have to iterate over the entire size of the vector more than once to ensure complete deallocation.

class CV{
    public:
            float x;
            float y;

            CV();
            CV(float, float);
            ~CV();
 };


int main(){

    vector<CV*>* cars;
    cars = new vector<CV*>;


    //create objects with new, push into vetor
    for(int j=0;j<4;j++){
            cars->push_back( new CV(10.0+j, 11.99+j) );
    }

    while( cars->size() > 0   ){
            for(int i=0;i<cars->size();i++){
                    delete (*cars)[i];
                    cars->erase( cars->begin()+i);
            }
            cout << "size:"<< cars->size() << endl;
    }

    delete cars;
    return 0;

}

This will output:

  size:2
  size:1
  size:0

The vector seems to iterate over every second element when I try to delete, as I require the extra while loop to ensure total deallocation.

I seem to be missing something about the internal workings of vector, I've tried reading the vector c++ reference and I understand that vectors store elements in a contiguous location and that they allocate extra storage for possible growth, but I fail to understand the behaviour of this code.

Answer 1

You can write a generic function to handle both deallocation and erasure of the vector's elements

template<typename T>
void destroy_vector(std::vector<T*> &v)
{
    while(!v.empty()) {
        delete v.back();
        v.pop_back();
    }
}

Some remarks

• Always check with empty for empty container
• Store your vector<T*>* in a smart pointer to avoid memory leaks

Answer 2

When you erase an element from vector, elements after that are moved by one place. When you erase the element in index 0, the element in index 1 will be moved to index 0 and will not be erased in the next iteration.

Take the erase from the loop. Elements will be erased in the vectors destructor anyway.

Answer 3

I think the real problem here is you miss the for loop condition check. I make a small change to your code:

auto validateLoopCondition = [](int index, const vector<CV*> *vecpCV)
{
    cout << "validate loop condition: i = " << index << ", size:" << vecpCV->size()
         << (index < vecpCV->size() ? ", keep it" : ", break out\r\n---------------\r\n")
         << endl; 
};

for (int i = 0;  validateLoopCondition(i, cars) , i < cars->size(); i++)
{
    delete (*cars)[i];
    cars->erase(cars->begin() + i);
}

cout << "size:" << cars->size() << endl;


//-out put-----------------------------------------------

validate loop condition: i = 0, size:4, keep it
validate loop condition: i = 1, size:3, keep it
validate loop condition: i = 2, size:2, break out
---------------

size:2
validate loop condition: i = 0, size:2, keep it
validate loop condition: i = 1, size:1, break out
---------------

size:1
validate loop condition: i = 0, size:1, keep it
validate loop condition: i = 1, size:0, break out
---------------

size:0

//-----------------------------------------------------

I have two suggestions which are also my questions:

1. use smart pointer here to manage the resource can help you.

2. use vector object on the stack will be better.

Answer 4

The reason this happens is very simple, you pull the rug out from under your own feet by erasing element i and then incrementing i...

i = 0: cars = {0}[1][2][3]

erase(begin + i)

i = 0: cars = {1}[2][3]

i++

i = 1: cars = [1]{2}[3]

erase(begin + i)

i = 1: cars = [1]{3}

i++

i >= cars.size()

Using erase like this is inefficient. You might consider the following two approaches:

while (!cars.empty()) {
    delete cars.back();
    cars.pop_back();
}

or the far more efficient

for (size_t i = 0; i < cars.size(); ++i) {
    delete cars[i];
}
cars.clear();