It's hard to tell from the terminology you've used and the code presented exactly what's going on. So maybe a few examples would help you out.
Array new and array delete
What's up with new []
and delete []
you ask? These guys are used for allocating/deallocating arrays of things. Those things could be POD or they could be full fledged objects. For objects they will call the constructor after allocating and destructor while deallocating.
Let's take a contrived example:
class MrObject
{
public:
MrObject() : myName(new char[9]) { memcpy(myName, "MrObject", 9); }
virtual ~MrObject() { std::cout << "Goodbye cruel world!\n"; delete [] myName; }
private:
char* myName;
};
Now we can do some fun stuff with MrObject.
Arrays of objects
First let's create a nice and simple array:
MrObject* an_array = new MrObject[5];
This gives us an array of 5 MrObjects, all nicely initialized. If we want to delete that array we should perform an array delete, which in turn will call the destructor for each MrObject. Let's try that:
delete [] an_array;
But what if we goofed up and just did a normal delete? Well now's a good time to try it for yourself
delete an_array;
You'll see that only the first destructor get's called. That's because we didn't delete the whole array, just the first entry.
Well sometimes. It's really undefined what happens here. The takeaway is to use the array form of delete when you use an array new, ditto for just plain old new and delete.
Vectors of Objects
OK, so that was fun. But let's take a look at the std::vector now. You'll find that this guy will manage the memory for you, and when he goes out of scope, well so does everything he's holding onto. Let's take him out for a test ride:
std::vector<MrObject> a_vector(5);
Now you have a vector with 5 initialized MrObjects. Let's see what happens when we clear that sucker out:
a_vector.clear();
You'll note that all 5 destructors got hit.
Vectors of Pointers to Objects
Oooooh you say, but now lets get fancy. I want all the goodness of the std::vector, but also want to manage all the memory myself! Well there's a line for that as well:
std::vector<MrObject*> a_vector_of_pointers(5);
for (size_t idx = 0; idx < 5; idx++) {
// note: it's just a regular new here, not an arra
a_vector_of_pointers[idx] = new MrObject;
}
See that was a bit more of a pain. But it can be useful, you could use a non-default constructor when creating MrObject. You could put derived MrObjects in there instead. Well as you can see the sky's the limit. But wait! You created that memory, you best manage it. You'll want to loop over each entry in the vector and cleanup after yourself:
for (size_t idx = 0; idx < a_vector_of_pointers.size(); idx++) {
delete a_vector_of_pointers[idx];
}