c++, object created on the heap vs. local - when returning a pointer

Question

This is a follow up question from Safe in C# not in C++, simple return of pointer / reference,

Is this:

person* NewPerson(void)
{
  person p;
  /* ... */
  return &p; //return pointer to person.
}

the same as?

person* NewPerson(void)
{
  person* pp = new person;

  return pp; //return pointer to person.
}

I know that the first one is a bad idea, because it will be a wild pointer. In the second case, will the object be safe on the heap - and like in c# go out of scope when the last reference is gone to it?

neither of these is C# code. The second one is a memory leak in C++ if you don't manually release it. — CodesInChaos, Dec 10 '11 at 17:00

score 3 · Answer 1 · answered Dec 10 '11 at 17:01

3

Yes, the second case is safe.

But the caller will need to delete the returned pointer. You could change this to use boost::shared_ptr and it will be destroyed when it is no longer in use:

boost::shared_ptr<person> NewPerson()
{
    boost::shared_ptr<person> pp = boost::make_shared<person>();

    return pp;
}

If C++11 then you can use std::shared_ptr or std::unique_ptr.

answered Dec 10 '11 at 17:01

hmjd

120,187
20
207
252

ok if the referenced pointers is set to 0 (null)? Or out of scope, like in c# – Niklas Dec 10 '11 at 17:06
If it goes out of scope or you set to NULL by calling `reset()` on the returned smart pointer. – hmjd Dec 10 '11 at 17:09

score 2 · Accepted Answer · answered Dec 10 '11 at 16:59

It's safe, the object will still be alive after the return.

But don't expect the object to be automatically cleaned up for you in C++. Standard C++ does not have garbage collection. You'll need to delete the object yourself, or use some form of smart pointer.

score 1 · Answer 3 · answered Dec 10 '11 at 17:01

person* NewPerson(void)
{
  person* pp = new person;

  return pp; //return pointer to person.
}
I know that the first one is a bad idea, because it will be a wild pointer. In the second case, will the object be safe on the heap - and like in c# go out of scope when the last reference is gone to it?

Correct on the first one: it would be returning a pointer to data on that functin's stack, which will be reclaimed and modified once the function finishes.

On the second case: the object is created on the heap, which is separate from the execution stack. When the function finishes, the object on the heap is safe and stays the same. However, C++ does not automatically do garbage collection, so if you lost all of the references to a heap object, this would constitute a memory leak--the object's space would not be reclaimed until the program ended.

score 0 · Answer 4 · answered Dec 10 '11 at 16:59

0

The latter is safe. However, C++ does not (usually) provide garbage-collection, and thus you need to arrange for an explicit delete of the returned object.

answered Dec 10 '11 at 16:59

ibid

3,891
22
17

score 0 · Answer 5 · answered Dec 10 '11 at 17:00

0

Like you say, the first case is bad as the pointer will not be valid. As for the second case, memory in C++ is not managed, you have to clean up after yourself. C++ doesn't keep track of references on normal pointer, that's what std::shared_ptr is for.

answered Dec 10 '11 at 17:00

Some programmer dude

400,186
35
402
621

c++, object created on the heap vs. local - when returning a pointer

5 Answers5

Linked