How do "safe delete" for both arrays and non-arrays?

I've seen numerous functions like:

Code:

---

template <typename T> void SafeDelete(T *&p)
{
    if ( p )
    {
          delete p;
          p = NULL;
    }
}

---

The check for p is so that you don't delete it twice (which would cause a problem). But if an array gets passed to it, you've got a problem.

Is there a way to do something *like* this:

Code:

---

template <typename T> void SafeDelete(T *&p)
{
    if ( p )
    {
          if ( isArray( p ) ) delete [] p;
          else delete p;
          p = NULL;
    }
}

---

The check for null is unnecessary unless you are coding on very very old compilers with bugs, in which case I'd be surprised if the template solution would work anyway. Remove the if ( p ).

As far as telling whether p was an array or not, I think you'd have to overload the function to take a different type. Although I wonder why you would need this for an array, why wouldn't you be using vector?

Quote:

---

Originally Posted by Daved

The check for null is unnecessary unless you are coding on very very old compilers with bugs, in which case I'd be surprised if the template solution would work anyway. Remove the if ( p ).

As far as telling whether p was an array or not, I think you'd have to overload the function to take a different type. Although I wonder why you would need this for an array, why wouldn't you be using vector?

---

I disagree. The following causes an error:

Code:

---

SomeClass* p;
delete p;
delete p;

---

I can't guarantee that SafeDelete won't be called twice in someone's code on the same pointer. So setting the variable to NULL and then not calling delete again on it is safer.

I said the check for null is unnecessary (the if ( p ) part). I didn't say the setting of the pointer to null was unnecessary.

I agree that setting the pointer to null can be useful in some cases. In my experience, however, most of the time when you delete a pointer it goes out of scope and is not used anyway.

Quote:

---

Originally Posted by 6tr6tr

I disagree. The following causes an error:

Code:

---

SomeClass* p;
delete p;
delete p;

---

I can't guarantee that SafeDelete won't be called twice in someone's code on the same pointer. So setting the variable to NULL and then not calling delete again on it is safer.

---

Someone could also delete, then SafeDelete. Or pass a pointer that was never new'd. You can't stop all errors this way. The best practice is to use smart pointers and containers instead of raw pointers and arrays. When you must use raw, practice RAII and delete them in the destructor.

There's no way to distinguish between array and single object pointers. You simply have to know which it is. 99.99% of the time, that's absolutely no problem.

Quote:

---

The best practice is to use smart pointers and containers instead of raw pointers and arrays. When you must use raw, practice RAII and delete them in the destructor.

---

In a way it appears that this SafeDelete is one of the unsafest ways to go about managing memory...

Well, it's safer than a raw delete ;)