Before the deletion, ptr‘s value was valid. After the deletion, the value was invalid. Therefore the value changed. Valid values and invalid values are mutually exclusive — a value cannot be simultaneously valid and invalid.
Your question has a basic misconception; you’re conflating these two different concepts:
- The value of a variable
- The representation of a variable in memory.
There isn’t a one-to-one correspondence between these two things. The same value may have multiple representations, and the same representation may correspond to different values.
I think the gist of your question is: can delete ptr; change the representation of ptr?. To which the answer is “Yes”. You could memcpy the deleted pointer into a char array, inspect the bytes, and find them all to be zero-valued bytes (or anything else). This is covered in the standard by C++14 [basic.stc.dynamic.deallocation]/4 (or C++17 [basic.stc]/4):
Any other use of an invalid pointer value has implementation-defined behavior.
It’s implementation-defined and the implementation could define that inspecting the bytes gives bytes with value zero.
Your code snippet relies on implementation-defined behaviour. “Valid code” isn’t terminology used by the Standard, but the code might not remove the intended item from the hash table.
As alluded to by Stroustrup, this is an intentional design decision. An example usage would be a compiler in debug mode setting deleted pointers to a particular representation, so that it can raise a runtime error if a deleted pointer is subsequently used. Here’s an example of that principle in action for uninitialized pointers.
Historical note: In C++11 this case was undefined, rather than implementation-defined. So the behaviour of using a deleted pointer was identical to the behaviour of using an uninitialized pointer. In the C language, freeing memory is defined as putting all pointers to that memory into the same state as an uninitialized pointer has.