What does the OS/Debugger do when a pointer is assigned 0?
Why is assigning 0 to a pointer a solution to a dangling pointer?
1k Views Asked by unj2 At
8
There are 8 best solutions below
0
On
A pointer to 0 is called a null pointer, and is usually used to indicate that it is not pointing to anything. This can be checked for by the debugger/runtime/compiler/whatever to be sure you don't have a pointer to invalid data. It's just an explicit recognition that the pointer isn't supposed to be pointing to anything just now.
3
On
Assigning 0 (or NULL, or whatever is pre-defined for you depending on your imports) to a pointer is a general convention used to indicate that:
- the pointer is unused (not pointing to a memory address of interest),
- and that it should NOT be dereferenced.
0
On
I guess it's more useful to the programer than to the OS/debugger.
OS/debugger doesn't care where the pointer is pointing to.
But it's useful for you to check if the pointer is pointing to somewhere meaningful.
0
On
Setting a pointer to 0 does not solve a dangling pointer problem. If the code thinks that a dangling pointer (by definition invalid) is valid, setting to 0 and dereferencing will still cause the program to manifest illegal behavior.
If the code happens to check a pointer for null before dereferencing, then setting the pointer to 0 can avoid illegal behaviour.
0
On
A null pointer is more important than just convention. You are allowed to free a nullptr and have it not do anything. It is also used as convention that the pointer isn't pointing to anything yet.
0
On
Why is assigning 0 to a pointer a solution to a dangling pointer?
@wikipedia::
To expose dangling pointer errors, one common programming technique is to set
pointers to the null pointer or to an invalid address once the storage they
point to has been released. When the null pointer is dereferenced
(in most languages) the program will immediately terminate—there is no potential
for data corruption or unpredictable behavior. This makes the underlying
programming mistake easier to find and resolve.
This technique does not help when there are multiple copies of the pointer.
.
What does the OS/Debugger do when a pointer is assigned 0?
@wikipedia::
though, that the physical address zero is often directly accessible by hardware (for
instance, it is directly accessible in x86 real mode, and it is where the interrupt
table is stored), but modern operating systems usually map virtual address spaces in
such a way that accessing address zero is forbidden.
0
On
Simply, to add to this long list of answers, the runtime will assign 0, or NULL to the pointer. The memory at the other end, unless previously freed (free() or operator delete) if it was dynamically allocated (malloc() and operator new), or just cleaned up automatically because it was an auto (all locals by default).
Assigning NULL to a pointer that has valid memory at the other end creates a memory leak. A memory leak is when the OS thinks that a process is still using some memory, but the process has no handle on the memory (it has lost the address), and thus has no way of freeing it or using it. The memory will be cleaned up when the process terminates, but for long-running processes, or process that leak multiple times, or, worst of all, programs that leak large amounts of memory can cause big problems.
If a process leaks enough memory, at the least it will make the system sluggish and force the user to kill it, in worse circumstances, it would invoke the OOM killer (on systems with one), or worse, crash the entire system because of lack of memory. Also, if you dereference a NULL pointer, on any modern OS you will cause a segfault or bus error, and on ancient OS', you could destroy the system (eg. DOS).
Debuggers may notify you if they have enough information, you can also use static analysis tools to find memory leaks, or runtime tools like valgrind. Memory leaks are one of the biggest problems for C/C++ programs, and are something to look for carefully before realeasing code.
The essential problem this solves is that not all CPU's implement the same sorts of memory dereference semantics. In some cases, it's not possible to make dereferencing an address after it has been
free()into anything that looks like an error. This is especially true on embedded processors. In other cases, allocators may be very lazy about returning freed memory to the host operating system, for performance reasons.Fundamentally, dereferencing such a pointer could lead to actually seeing the freed region, seeing a zeroed out region, seeing memory that has been returned by a subsequent allocation, or causing a cpu exception. Since such an eventuality is completely reasonable, c++ has assigned this condition as "undefined behavior".
To get out of that situation, you want to have a way of distinguishing pointer values which have been freed or allocated. As such, C++ requires that dereferencing a pointer that has been assigned
0is an error, and converting such a pointer to an integer also return zero.re: your current edit.
pointers don't exist for the purposes of operating systems. At the lowest level, there are no strings, integers, floats or pointers of any sort. only bytes. When you write a c++ program that assigns 0 to a pointer value, the operating system simply doesn't enter into the equation. that's totally up to the compiler implementation.
On the other hand, when you dereference such a pointer in your program, c++ requires that this is be a runtime error. On embedded systems, that's basically not practical, 0 is a perfectly valid memory address on such systems, usually the SRAM is near that address. If the compiler strictly implements the standard, it might insert a check before every dereference to see if it was null, and put the MCU in an error state, but that's unusual, since it would slow an already slow system and increase program size.
On more fully featured systems, those that have a memory management unit, the zero address in the application is usually not mapped to any physical page, so the operating system does help you here, by raising a segfault in the page program when it tries to access the null pointer value.