Printable View
Hi,
I learned that deleting memory that has not been allocated will cause segment fault. e.g.
.Code:int main ()
{
int * p;
delete p;
}
However, I have seen in someone's code that
It seems work fine.Code:int main ()
{
int * p = 0;
delete p;
}
Is the second one legal? Does this mean that the memory at address 0 is somehow special?
How to check if a memory has been allocated before deleting it?
Thanks and regards!
If you haven't allocated memory, then don't try to free it. If you have code where you "don't know" if it's allocated or not, then you do indeed need to make sure you have it set to 0 (aka NULL) when it's not allocated.
You do not delete the pointer, you delete the memory that it is pointing to. If it's not pointing to memory that you got through new, then it should not be deleted.
--
Mats
It means that delete only deletes the pointer if it's != 0.
Deleting a NULL pointer (aka a pointer with a value of 0) is perfectly legal (as defined by the standard). Deleting anything non-allocated is undefined behavior.
From OP:
How to check if a memory has been allocated before deleting it?
First, the only way to 'check' is to insist that all unallocated pointers are initialized to 0, which then answers your question - all non-zero pointers would refer to allocated space.
However, this doesn't address the potential that a pointer that once identified a valid memory location has not been 'deleted' by some other code, where the pointer in question has not been set to zero after the delete.
This problem is one reason that many modern C++ developers use smart pointers, especially reference counted smart pointers. In trivial code it may seem unimportant and not worth any performance penalty, but as the ambition of the target application increases, the complexity of designs, especially in the presence of threaded designs, virtually demands the use of smart pointers.
I don't disagree with the purpose/use of smart pointers, but I fail to see what threading has to do with the matter?Quote:
Originally Posted by JVene
--
Mats
If you are sharing objects among threads, reference counting is the easiest way to ensure that the object lifetime is managed correctly. I believe that was his point in regards to multi-threaded applications (granted it has little to do with the original post).Quote:
I don't disagree with the purpose/use of smart pointers, but I fail to see what threading has to do with the matter?
bithub has my point correct, exactly.
..and yes, I'm drifting - sorry. I think it is a tributary of the subject that eventually does apply on the general question of containment, the subject from which the OP's question derives.
Perhaps I'm too far beyond the scope of the topic, though.
Yes, it's completely legal and normal. 0 (or commonly known as NULL) is a special address effectively meaning "not allocated".Quote:
Originally Posted by lehe
You don't check if memory has been allocated before deleting it. You simply start out with the pointer set to NULL and if nothing changes that pointer then it is totally safe and normal to just call delete on it regardless. You don't have to check for NULL because they were kind enough to make that check built into delete.