stackoverflow.com › questions › 17997228 › what-is-a-dangling-pointer

A dangling pointer is a pointer that points to invalid data or to data which is not valid anymore, for example:

Class *object = new Class();
Class *object2 = object;

delete object;
object = nullptr;
// now object2 points to something which is not valid anymore

This can occur even in stack allocated objects:

Object *method() {
  Object object;
  return &object;
}

Object *object2 = method();
// object2 points to an object which has been removed from stack after exiting the function

The pointer returned by c_str may become invalid if the string is modified afterwards or destroyed. In your example you don't seem to modify it, but since it's not clear what you are going to do with const char *name it's impossible to know it your code is inherently safe or not.

For example, if you store the pointer somewhere and then the corresponding string is destroyed, the pointer becomes invalid. If you use const char *name just in the scope of new_foo (for example, for printing purposes) then the pointer will remain valid.

Answer from Jack on Stack Overflow

GeeksforGeeks

geeksforgeeks.org › c++ › dangling-pointers-in-cpp

Dangling Pointers in C++ - GeeksforGeeks

July 20, 2026 - Can cause unpredictable program behavior if accessed after the referenced memory becomes invalid. ... Example: The following program shows a dangling pointer created after deleting dynamically allocated memory.

Stack Overflow

stackoverflow.com › questions › 17997228 › what-is-a-dangling-pointer

c++ - What is a dangling pointer? - Stack Overflow

Dangling Pointer

When a pointer is pointing at the memory address of a variable but after some time that variable is deleted from that memory location while the pointer is still pointing to it, then such a pointer is known as a dangling pointer and this problem is known as the dangling pointer problem.

Initially

Later

Example

#include<stdio.h>

int *call();
int main() {

  int *ptr;
  ptr = call();

  fflush(stdin);
  printf("%d", *ptr);
  return 0;
}

int * call() {
  int x=25;
  ++x;

  return &x;
}

Its output will be garbage because the variable x is a local variable. Its scope and lifetime are within the function call hence after returning the address of x variable x becomes dead and the pointer is still pointing to that location.

c++ - Dangling pointer: reference to local variable not destroying

c++ - What is a dangling reference?

Delete dangling pointer in C++

Clarify dangling pointer in C/C++

c++ - I don't understand why I have a dangling pointer

More results from stackoverflow.com

Discussions

[C++] Wikipedia dangling pointer example

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

r/learnprogramming

17

2

January 25, 2013

Dangling pointers in C - Stack Overflow

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 create dangling pointer. More on stackoverflow.com

stackoverflow.com

unique_ptr and dangling references

Here's a shorter demonstration: template Copyable& foot_gun(const Copyable& src) { return *(std::make_unique(src).get()); } It's the difference between syntax and semantics. That's what static analysis tools try to help us figure out. part of me was expecting the reference to have been magically nulled somehow. It might! If the referenced object's destructor cleans everything up to some ground state, it's entirely possible that calls to the object's methods will all return some sensible nothing-value. It's also entirely possible that the compiler will decide that there's no reason to do the cleanup because those values are legally inaccessible after the destructor exits--so the calls will work as if the object weren't destroyed (until something stomps on that heap space). It's possible that the behavior on the same compiler will differ depending on whether you're running a "debug" build or a "release" build (because of different compiler flags). You can waste days chasing ghosts! Static analysis tools and -fsanitize are your friends. More on reddit.com

r/cpp_questions

10

1

August 18, 2021

Is this an example of a dangling pointer?

It tried to read a field from a pointer to a struct but the pointer was null. Not a dangling pointer seeing as it probably wasn't deallocated (it would most likely be a different random address) but rather a null pointer. More on reddit.com

r/rust

3

0

April 15, 2025

What is a dangling pointer?

stackoverflow.com › questions › 17997228 › what-is-a-dangling-pointer

A dangling pointer is a pointer that points to invalid data or to data which is not valid anymore, for example:

Class *object = new Class();
Class *object2 = object;

delete object;
object = nullptr;
// now object2 points to something which is not valid anymore

This can occur even in stack allocated objects:

Object *method() {
  Object object;
  return &object;
}

Object *object2 = method();
// object2 points to an object which has been removed from stack after exiting the function

The pointer returned by c_str may become invalid if the string is modified afterwards or destroyed. In your example you don't seem to modify it, but since it's not clear what you are going to do with const char *name it's impossible to know it your code is inherently safe or not.

For example, if you store the pointer somewhere and then the corresponding string is destroyed, the pointer becomes invalid. If you use const char *name just in the scope of new_foo (for example, for printing purposes) then the pointer will remain valid.

Answer from Jack on Stack Overflow

Videos