Bring the best of human thought and AI automation together at your work. Explore Stack Internal ... Save this question. Show activity on this post. I don't understand concept of dangling pointer, was googling around, and writing test methods to find one. More on stackoverflow.com

When a pointer is allocated memory using malloc, pointer (say x)will now point to memory address. Later I free this(x) memory pointer,but pointer is still pointing to it's old memory. This would now More on stackoverflow.com

I'll try to explain a bit more visually and concrete. First let me change the code just a tiny bit. int* a = new int; int* b = a; delete b; /* a and b are now dangling pointers */ *a = 4; /*Memory error*/ This is to show you what the star actually means. It's essentially a different variable type. A pointertype of the regular type. So a variable of the type int* points to a memory location that contains an int. Now: In the first line of code you allocate memory for an int with the code 'new int'. Let's call the adress of this memory location XXX. Then you point the pointer 'a' to this location 'int* a ='. a now points to location XXX. In the second line of code you tell the pointer b to point to the same location as a. a and b now both point to location XXX. In the third line of code you delete the memory b is pointing to. The location XXX is empty and no longer contains an int and can be reused, possibly by processes that you do not control. So you shouldn't overwrite it! This is why a and b are now dangling pointers, they no longer point to accessible memory. In the fifth line you try to overwrite the location XXX, which you had already freeed. This causes an error as you do not have permission to do this. The star operator here is different from the star used to make a pointer. The star here means you dereference the pointer, which essentially means, you get the variable it points to (which usually does not have a name). You get the content of adress XXX. Here's an extra example on the use of the astrix. int anInt = 5; /*the value of anInt is 5, this is stored at a memory location*/ int* aPointer; /*the pointer does not point to anywhere*/ *aPointer = 10; /* the pointer points to a memory location that contains 10*/ int* anOtherPointer = &anInt; /*the &-operator returns the location of a variable, anOtherPointer now points to anInt*/ aPointer = anOtherPointer /*aPointer now also points to anInt*/ I hope this clears things up a bit. EDIT: What work__account said. More on reddit.com

When you have a dangling pointer, you've freed the memory (or if it's a pointer to something on the stack the memory it points to is now being used by something else). In this case if you dereference it you might get an error if you free'd it and the page got returned to your OS, or you might get garbage data if something else is using the memory, or everything might just work fine if nothing else has started using that memory. You shouldn't dereference it because it's undefined behaviour and the compiler doesn't have to make any guarantees about what will or will not happen when you do it. This is why you'll get different behaviour depending on lots of factors like the compiler used and optimisation settings. More on reddit.com