dangling-pointer

C++ code: person* NewPerson(void) { person p; /* ... */ return &p; //return pointer to person. } C# code: person NewPerson() { return new person(); //return reference to person. } If I understand this right, the example in C++ is not OK, because the p will go out of scope, and the function will return a wild pointer (dangling pointer). The example in C# is OK, because the anonymous new person will stay in scope as long as there is a reference to it. (The calling function gets one.) Did I get this right? Xeo person* NewPerson(void) { person p(); /* ... */ return &p; //return pointer to person.

This question already has an answer here: delete vs NULL vs free in c++ 6 answers Is saying delete pointer and pointer = nullptr the same? Probably not, but does the latter free up memory? What about delete pointer; pointer = nullptr / pointer = nullptr; delete pointer ? Why not use that to make a safe way to delete pointers prematurely if required, where they would normally be deleted some other time and cause an error with a normal delete? It is not the same, because while you may be setting the pointer to null, the contents that the pointer pointed to would still be taking up space. Doing

Clang 3.9 extremely reuses memory used by temporaries. This code is UB (simplified code): template <class T> class my_optional { public: bool has{ false }; T value; const T& get_or_default(const T& def) { return has ? value : def; } }; void use(const std::string& s) { // ... } int main() { my_optional<std::string> m; // ... const std::string& s = m.get_or_default("default value"); use(s); // s is dangling if default returned } We have tons of code something like above ( my_optional is just a simple example to illustrate it). Because of UB all clang compiler since 3.9 starts to reuse this

I wrote a program in C having dangling pointer. #include<stdio.h> int *func(void) { int num; num = 100; return &num; } int func1(void) { int x,y,z; scanf("%d %d",&y,&z); x=y+z; return x; } int main(void) { int *a = func(); int b; b = func1(); printf("%d\n",*a); return 0; } I am getting the output as 100 even though the pointer is dangling. I made a single change in the above function func1() . Instead of taking the value of y and z from standard input as in above program, now I am assigning the value during compile time. I redefined the func1() as follows: int func1(void) { int x,y,z; y=100; z

Is it legal to compare dangling pointers? int *p, *q; { int a; p = &a; } { int b; q = &b; } std::cout << (p == q) << '\n'; Note how both p and q point to objects that have already vanished. Is this legal? Introduction: The first issue is whether it is legal to use the value of p at all. After a has been destroyed, p acquires what is known as an invalid pointer value . Quote from N4430 (for discussion of N4430's status see the "Note" below): When the end of the duration of a region of storage is reached, the values of all pointers representing the address of any part of the deallocated storage