According to everything I have read, I should be able to call delete on a pointer more than once without a crash. I recently ran into an issue with Visual Studio where the destructor was called more than once. That was due to a problem in my code and was corrected, but oddly, this caused a crash. If I did this, there was no crash:

~destructor()

{
if(pointer != NULL)

{

delete pointer;

pointer = NULL;

}
}

[\code]

This isn't supposed to be necessary, correct? Is Visual Studio screwed up or is this supposed to happen?

According to everything I have read, I should be able to call delete on a pointer more than once without a crash.

You have been reading in the wrong places. As you have just discovered, double delete is a very real programming error.

Attempting to delete a null object results in a nul-op. Basically delete does this:

delete( void* thing)

{

if(thing)

real_delete(thing);

}

If you call delete, the very next line should be to assign the pointer to NULL.

Or you can avoid the problem entirely by using smart pointers and container classes.

No, really. Use smart pointers and container classes. Assume that a naked pointer is a bug in progress.

This was a bug that presented itself during a call to a copy constructor that was copying image data contained in a pointer of unsigned chars. I use container classes, but smart pointers are a little overkill for this application.

Thanks for the info. I misunderstood. I failed to set the pointer to NULL after the call to delete.

This was a bug that presented itself during a call to a copy constructor that was copying image data contained in a pointer of unsigned chars. I use container classes, but smart pointers are a little overkill for this application.

Thanks for the info. I misunderstood. I failed to set the pointer to NULL after the call to delete.

Pointers do not contain unsigned chars or image data. Pointers point to a location in memory. /pedantic

More importantly, what is going on in your program that your structure is encountering objects that may or may not be deleted?

Yeah, I mistyped. :o I was remembering the code (unsigned char *image_data) as I typed and typed that.

As to the question, I am going from memory and I don't remember exactly what was going on. I do know that the code was structured badly and I corrected it. My confusion was in not remembering that it is OK to delete a pointer set to NULL. I thought it was OK to delete a pointer more than once.

To be honest, I have always used raw pointers for image data. I really never gave smart pointers much thought. I'll experiment with them tonight.

That's often one of two problems. First, code bases have a tendency to be ancient. std::auto_ptr was often a heptagon in a world of mainly round and square holes. Template support was very shaky on early compilers (and still is on some platforms). Boost was not always an option.

Secondly, a sadly high number of 'C++ programmers' have decided to call themselves that after reaching the 'C with classes' state and never evolved from there.