Variable/pointer scope (rookie Qs)

I have 3 pieces of code below. A simple one really - just need to know which ones are safe. I think A and maybe C is safe. However, B is dangerous from my experience, but I'm not exactly sure why as the memory inside has been allocated to the heap, so it should last 'forever', and not just be local to the function.

Code:

---

// A: I think this is safe:
#include <iostream>
struct prvs {        int quantity;        };
prvs* pr() {
        prvs* p = new prvs;        p->quantity=3;
        return p;
}
int main(int argc, char**argv)
{
        prvs* prv = pr();
}



// B: I think this is dangerous:
#include <iostream>
struct prvs {        int quantity;        };
prvs pr() {
        prvs* p = new prvs;        p->quantity=3;
        return *p;
}
int main(int argc, char**argv)
{
        prvs* prv = &pr();        // Will this pointer's contents always survive?
}



// C: I'm not so sure about this one
#include <iostream>
struct prvs {        int quantity;        };
prvs pr() {
        prvs* p = new prvs;        p->quantity=3;
        return *p;
}
int main(int argc, char**argv)
{
        prvs prv = pr();
}

---

Quote:

---

Originally Posted by twinbee

I have 3 pieces of code below. A simple one really - just need to know which ones are safe. I think A and maybe C is safe. However, B is dangerous from my experience, but I'm not exactly sure why as the memory inside has been allocated to the heap, so it should last 'forever', and not just be local to the function.

Code:

---

// A: I think this is safe:
#include <iostream>
struct prvs {    int quantity;    };
prvs* pr() {
    prvs* p = new prvs;    p->quantity=3;
    return p;
}
int main(int argc, char**argv)
{
    prvs* prv = pr();
}



// B: I think this is dangerous:
#include <iostream>
struct prvs {    int quantity;    };
prvs pr() {
    prvs* p = new prvs;    p->quantity=3;
    return *p;
}
int main(int argc, char**argv)
{
    prvs* prv = &pr();    // Will this pointer's contents always survive?
}



// C: I'm not so sure about this one
#include <iostream>
struct prvs {    int quantity;    };
prvs pr() {
    prvs* p = new prvs;    p->quantity=3;
    return *p;
}
int main(int argc, char**argv)
{
    prvs prv = pr();
}

---

---

Just FYI, this should be posted to the C++ forum.

Anyway, 'A' is correct, *but* you fail to delete the memory afterwords. 'B' creates a memory-leak, and attempts to obtain the address of an anonymous variable, which is a big no-no (you can form an "immutable temporary" by assigning the return value to a const reference, but that's more advanced stuff). 'C' also has a memory leak...

Thanks. Can you confirm that B would crash or produce strange output (even without any memory leak) if the program was longer? I still don't understand why it's bad though, since the variable that's being returned was allocated on the heap, not on the stack.

As for code part C, I take it that there would still be a memory leak inside the funtion, even if I used delete at the end?

B isn't right at all on the assignment. You can't get the address of something you return by value. It's like saying:

Code:

---

int foo() { return 5; } ... int *bar = &foo();

---

It shouldn't compile. Invalid lvalue.


Quzah.