指向对象的指针向量-内存泄漏

Question

I have a vector of pointers to class objects. These class objects invoke "new" as well to create an array.

I'm trying to avoid memory leaks, so I created a destructor which returns the object's array back to freestore.

laboratory::~laboratory()
{
   delete Users;   // Users is an array from the heap
}

When I try to delete each element of the pointer vector, however, the program crashes:

for(int i = 0; i < vectorSize; i++)
    delete labVector[i];

Any help is much appreciated.

Edit: Pasted code here: http://pastie.org/4168453

Class and function definitions are below main(). Sorry for pasting it this way, I was using a header file and 2 source files.

Answer 1

delete Users;   // Users is an array from the heap

Well then that's wrong. Should be

delete [] Users;

Anything you new with [] gets a delete with [] .

On a side note; do you really need a vector of pointers here? It's pretty darn rare to actually need that (though you see it a lot) and it completely negates the container's ability to manage memory for you, requiring you to loop through and deallocate every element.

vectors use dynamic memory behind the scenes for each element. You could us a vector of smart pointers or even a vector<vector<T>> (though, if performance is of the utmost concern, a jagged array may be a better choice. Don't assume that though).

Answer 2

除非您绝对需要自己执行此操作，否则请考虑使用Boost ptr_vector 。

Answer 3

You have a few choices:

1. You can make it clear that the vector does not own the objects in it, only the pointers to them. It then becomes the responsibility of all code that uses this vector to allocate and delete the objects itself.

2. You can use a boost ptr_vector for this. The vector will own the objects it contains pointers to. You'll need to write a helper function to duplicate the objects so that x = y; will work. (Since x will need to own its own copy of every object in y .)

3. You can use smart pointers, such as boost::shared_ptr , for this. If you do x = y; , the two vectors will refer to the same objects, such that changing the value in one will change the value in the other. The vectors will share ownership of the objects and can return safe references to the objects in them. The objects will self-destruct when they are no longer needed.

4. You can use a vector of boost::any objects. This performs poorly but is very flexible.

But it really comes down to the classic question: What are you trying to do? Are you trying to manage the lifetimes of objects? If you duplicate a vector, what should happen? Should that duplicate the underlying objects? Do you need polymorphism? Are you using pointers to avoid slicing? And so on. Explain your use case and you'll get better solution suggestions.

Update : Your use of a vector of pointers seems simple and safe (so long as you don't try to copy-construct a vector, assign it, or anything like that). That your delete loop is crashing suggests possibly a bug in your destructor.

Update2 : Yep.

laboratory::~laboratory()
{
    delete stationUsers;
}

This is wrong because stationUsers wasn't allocated with new but with new[] .

Answer 4

没有更多代码很难知道，但请考虑：

delete[] Users;

Answer 5

Do not allocate an array from the heap yourself. Use std::vector<User> . In addition, you should never, ever use delete or delete[] yourself. Always use a class-based solution such as smart pointers or std::vector to manage your memory.

Answer 6

In addition to the others comments, your code has an Off-by-One error. This code references one past the end of your array.

for(int i = 0; i `<` vectorSize; i++)
    delete labVector[i];