I have a struct like this:
class Items
{
private:
struct item
{
unsigned int a, b, c;
};
item* items[MAX_ITEMS];
}
As Kluge pointed out, you'd leak the object at index 5 like that. But this one really sounds like you shouldn't do this manually but use a container class inside Item
. If you don't actually need to store these item
objects as pointers, use std::vector<item>
instead of that array of MAX_ITEMS
pointers. You can always insert or erase vector elements in the middle as well if you need to.
In case you need to store the objects as pointers (usually if struct item
is actually polymorphic, unlike in your example), you can use boost::ptr_vector<item> from Boost.PtrContainer instead.
Example:
class Items {
private:
struct item {
unsigned int a, b, c;
};
std::vector<item> items;
}
if (items.size() > 5) // (just to ensure there is an element at that position)
items.erase(items.begin() + 5); // no need to use operator delete at all
Say I wanted to 'delete' an item, like so:
items[5] = NULL;
I know little Visual Basic, but that smells like a Visual Basic programming idiom, since "Set a = None" (or Null, I'm not sure) would delete the object pointed by a (or rather decrement its reference count, for COM objects).
As somebody else noted, you should use either:
delete items[5];
items[5] = newContent;
or:
delete items[5];
items[5] = NULL;
After delete[5]
, the only possible use of the pointer stored in items[5]
is causing you trouble. What's worse is that it might happen to work at the beginning, and start failing only when you allocate something else over the space previously used by *items[5]
. Those are the causes which make C/C++ programming "interesting", i.e. really annoying (even for who likes C like me).
Writing just delete items[5];
saves what can be an useless write, but that's a premature optimization.
To delete an item use:
delete items[5];
after deleting the item it is advisable to set the deleted pointer to NULL, so you won't have an error if you later delete it again by mistake.
items[5] = NULL
Just to be clear: you refer to calling "delete[]
". I think you mean delete
.
I mention this because C++ has two separate operators, operator delete
and operator delete[]
. The latter is used for deleting arrays of objects allocated with operator new[]
, and does not apply in this case. You have an array of pointers to objects, which you must have initialised with repeated calls to operator new
rather than a single call to operator new[]
.
All I'm really trying to say is: your use of delete[]
is confusing and ambiguous; change it to delete
.
There are a few, related, questions here:
struct
is, so you don't need to delete[]
the array. If you created the array with new[]
you would have to delete[]
it.C++ isn't my strong suit, but I'm pretty sure you'd be leaking the memory if you set the pointer to NULL
.
EDIT: The memory being leaked would be the memory being pointed to by the pointer in the array.