It’s to support: // dynamically create object that cannot be changed const Foo * f = new Foo; // use const member functions here // delete it delete f; But note that the problem is not limited to dynamically created objects: { const Foo f; // use it } // destructor called here If destructors … Read more
From the standard (5.3.5/2) : In the first alternative (delete object), the value of the operand of delete shall be a pointer to a non-array object or a pointer to a sub-object (1.8) representing a base class of such an object (clause 10). If not, the behavior is undefined. In the second alternative (delete array), … Read more
5.3.5/7 says: If the value of the operand of the delete-expression is not a null pointer value, the delete-expression will call a deallocation function (3.7.4.2). Otherwise, it is unspecified whether the deallocation function will be called. And 3.7.4.2/3 says: The value of the first argument supplied to a deallocation function may be a null pointer … Read more
1 & 2 myVar = 8; //not dynamically allocated. Can’t call delete on it. myPointer = new int; //dynamically allocated, can call delete on it. The first variable was allocated on the stack. You can call delete only on memory you allocated dynamically (on the heap) using the new operator. 3. myPointer = NULL; delete … Read more
I noticed that the address stored in ptr was always being overwritten with 00008123… This seemed odd, so I did a little digging and found this Microsoft blog post containing a section discussing “Automated pointer sanitization when deleting C++ objects”. …checks for NULL are a common code construct meaning that an existing check for NULL … Read more
Stroustrup himself answers. An excerpt: C++ explicitly allows an implementation of delete to zero out an lvalue operand, and I had hoped that implementations would do that, but that idea doesn’t seem to have become popular with implementers. But the main issue he raises is that delete’s argument need not be an lvalue.
One question that the answers given so far don’t seem to address: if the runtime libraries (not the OS, really) can keep track of the number of things in the array, then why do we need the delete[] syntax at all? Why can’t a single delete form be used to handle all deletes? The answer … Read more
The destructor of A will run when its lifetime is over. If you want its memory to be freed and the destructor run, you have to delete it if it was allocated on the heap. If it was allocated on the stack this happens automatically (i.e. when it goes out of scope; see RAII). If … Read more
The delete operator deallocates memory and calls the destructor for a single object created with new. The delete [] operator deallocates memory and calls destructors for an array of objects created with new []. Using delete on a pointer returned by new [] or delete [] on a pointer returned by new results in undefined … Read more
The C++ FAQ Lite has a entry specifically for this https://isocpp.org/wiki/faq/freestore-mgmt#delete-this I think this quote sums it up nicely As long as you’re careful, it’s OK for an object to commit suicide (delete this).