The easy solution is to use smart pointers. If you really want for “copies” of your pointer to also be nullified use a combination of shared_ptr and weak_ptr.
......
Concerning low-level code: It too should use at least std::unique_ptr instead of raw pointers. With just some minimal support for function inlining it is as efficient as what you are proposing. shared_ptr has some overhead, but unique_ptr doesn’t.
The feature you want could just be a compiler flag. It does not have to be standardized to be able to do this. A static analyzer could also look for places in the code where a delete is not immediately followed by zeroing the pointer. One big exception for this is destructors: zeroing the pointer inside the destructor can (and will) be optimized out because the lifetime of the object containing the pointer has ended.
unique_ptr and shared_ptr have two distinct paradigms .
1-
unique_ptr moves the ownership totally, and to get back ownership , the callee need to return a unique_ptr
{
unique_ptr p=...;
//assuming callee1 returns a unique_ptr
p = move(callee1(move(p)));
}
BUT!!!, By the time callee1 returns, we don't know if the original resource or different resource is returned.
2-
shared_ptr models sharing ownership, but only the counter decides when to free the resource.
With the proposal + 'passing by reference' guideline, we are modeling a paradigm, of allocate in one location, free from anywhere and all are notified.
But definitely, if it can be done by a compiler flag then it does the job.