Is it safe to delete a NULL pointer?

327

votes

And is it a good coding style?

c++pointersmemory-managementnull-pointerdelete-operator

Good practice is to write C++ programs without a single call to delete. Use RAII instead. That is, use std::vector<T> v(100); instead of T* p = new T[100];, use smart pointers like unique_ptr<T> and shared_ptr<T> that take care of deletion instead of raw pointers etc. - fredoverflow

thanks to make_shared (c++11) and make_unique (c++14) your program should contain zero of new and delete - sp2danny

There may still be some rare cases that require new/delete, eg atomic<T*>: atomic<unique_ptr<T>> isn't allowed and atomic<shared_ptr<T>> has overhead that may be unacceptable in some cases. - atb

To declare a class with resource management using RAII you need to call new and delete right?, or you are saying there is some template class to hide this even this. - VinGarcia

@VinGarcia The point is that most user/client (that is: non-library) code should never have to write new or delete. Classes designed to manage resources, where Standard components can't do the job, can of course do what they need to do, but the point is that they do the ugly stuff with the memory they manage, not the end-user code. So, make your own library/helper class to do new/delete, and use that class instead of them. - underscore_d

292

votes

delete performs the check anyway, so checking it on your side adds overhead and looks uglier. A very good practice is setting the pointer to NULL after delete (helps avoiding double deletion and other similar memory corruption problems).

I'd also love if delete by default was setting the parameter to NULL like in

#define my_delete(x) {delete x; x = NULL;}

(I know about R and L values, but wouldn't it be nice?)

82

votes

From the C++0x draft Standard.

$5.3.5/2 - "[...]In either alternative, the value of the operand of delete may be a null pointer value.[...'"

Of course, no one would ever do 'delete' of a pointer with NULL value, but it is safe to do. Ideally one should not have code that does deletion of a NULL pointer. But it is sometimes useful when deletion of pointers (e.g. in a container) happens in a loop. Since delete of a NULL pointer value is safe, one can really write the deletion logic without explicit checks for NULL operand to delete.

As an aside, C Standard $7.20.3.2 also says that 'free' on a NULL pointer does no action.

The free function causes the space pointed to by ptr to be deallocated, that is, made available for further allocation. If ptr is a null pointer, no action occurs.

50

votes

Yes it is safe.

There's no harm in deleting a null pointer; it often reduces the number of tests at the tail of a function if the unallocated pointers are initialized to zero and then simply deleted.

Since the previous sentence has caused confusion, an example — which isn't exception safe — of what is being described:

void somefunc(void)
{
    SomeType *pst = 0;
    AnotherType *pat = 0;

    …
    pst = new SomeType;
    …
    if (…)
    {
        pat = new AnotherType[10];
        …
    }
    if (…)
    {
        …code using pat sometimes…
    }

    delete[] pat;
    delete pst;
}

There are all sorts of nits that can be picked with the sample code, but the concept is (I hope) clear. The pointer variables are initialized to zero so that the delete operations at the end of the function do not need to test whether they're non-null in the source code; the library code performs that check anyway.

22

votes

Deleting a null pointer has no effect. It's not good coding style necessarily because it's not needed, but it's not bad either.

If you are searching for good coding practices consider using smart pointers instead so then you don't need to delete at all.

11

votes

To complement ruslik's answer, in C++14 you can use this construction:

delete std::exchange(heapObject, nullptr);

3

votes

It is safe unless you overloaded the delete operator. if you overloaded the delete operator and not handling null condition then it is not safe at all.

0

votes

There is a FAQ on this matter which answers this question.

The C++ language guarantees that delete p will do nothing if p is null. Since you might get the test backwards, and since most testing methodologies force you to explicitly test every branch point, you should not put in the redundant if test.

-4

votes

I have experienced that it is not safe (VS2010) to delete[] NULL (i.e. array syntax). I'm not sure whether this is according to the C++ standard.

It is safe to delete NULL (scalar syntax).

Is it safe to delete a NULL pointer?

8 Answers