What does delete command really do for memory, for pointers in C++? [duplicate]

Answer 1

The delete operator frees the memory which was previously allocated using the new operator. This means that the memory is now available to be used by the system, for instance when there is another use of new later in the program. It does not clear the data in the memory, however. The pointer will still point to the same address in memory, but accessing that block will result in undefined behavior.

It is good practice to set a pointer to NULL (or nullptr in C++11) after deleteing it. Any subsequent deletes will be harmless.

Answer 2

Dereferencing the pointer after delete-ing it is undefined behavior, so anything can happen.

Usually, delete marks the memory as freed so it can be reused later, but this is a complicated topic.

Rule of thumb: never, ever use new and delete directly (except for implementing make_unique, which the standard lacks for some reason); use RAII.

Answer 3

delete makes the memory available for later requests via new. Whether or not it scrambles to content is undefined. Since it is faster to leave the contents as they are, in release mode it will probably appear that the memory is still "available". In debug mode, it might get scrambled with magic numbers.

What you're experiencing here is called "undefined behavior" in C++. In this case, the undefined behavior is caused by accessing a piece of memory after its lifetime has ended. Just don't do it.

Answer 4

delete returns the memory back to the system -- basically, it is no longer reserved for your program anymore. That does not mean that the values in the memory will be immediately overwritten, but the could be at any time after the delete is done. Most of the time, the same memory is reallocated to some future use by your own program.

Answer 5

Your experiment has undefined behavior as soon as you dereference the pointer after the delete statement. Everything can happen, which makes your experiment rather worthless.

What does delete (not delete[]) do? It deallocates the storage pointed to by its argument. This will trigger the destructor of the object stored at that location to be run. Accessing storage that has been deleted triggers undefined behavior (often a segmentation fault). There are no guarantees that the memory is actually handed back to the operating system or anything else.

Answer 6

Think of memory as a big warehouse with lots of boxes to put things into. When you call "new", the warehouse staff finds an unused box large enough for your needs, records that box as being owned by you (so it's not given to someone else), and gives you the number of that box so you can put your stuff into it. This number would be the "pointer".

Now, when you "delete" that pointer, the reverse happens: the warehouse staff notes that this particular box is available again. Contrary to real warehouse staff they aren't doing anything with the box — so if you look into it after a "delete" you might see your old stuff. Or you might see somebody else’s stuff, if the box was reassigned in the meantime.

Technically, you are not allowed to look into your box once you have returned it to the pool, but this is a somewhat weird warehouse with no keys or guards, so you can still do whatever you want. However, it might cause problems with the new owner of the box, so it's expected that you follow the rules.