Best way of returning a pointer - c++

Question

I have seen at least 5 C++ tutorial sites that return pointers this way:
int* somefunction(){
int x = 5;
int *result = &x;
return result;
}
Is that not a very, VERY bad idea? My logic tells me that the returned pointer's value can be overwritten at any time. I would rather think that this would be the right solution:
int* somefuntion(){
int x = 5;
int* result = new int;
*(result) = x;
return result;
}
And then leave the calling function to delete the pointer. Or am i wrong?

Answer 1

Your instinct about the problem is correct- UB is the result. However, your proposed solution is le bad. "Leave the caller to delete it" is hideously error prone and unadvisable. Instead, return it in some owning class that properly encapsulates it's intended usage- preferably std::unique_ptr<int>.

Answer 2

Yes, the first option will return a dangling pointer, and leads to undefined behavior. Your second option is correct, although you could just write:
int* somefuntion(){
return new int(5);
}
or having a static variable inside the method and returning its address.

Answer 3

Yes, the first example is not good as you'll be returning a pointer to memory that the system may re-purpose for something else. The second example is better, but still risks leaking memory as it's not clear to the caller of somefunction that it's their responsibility to delete the memory that's pointed at.
Something like this might be better:
std::unique_ptr<int> somefunction(){
int x = 5;
std::unique_ptr<int> result( new int );
*result = x;
return result;
}
This way, the unique_ptr will take care of delete'ing the memory that you new'ed, and will helpfully help to eliminate potential memory leaks.

Answer 4

Your question mixes several different issues into one. In reality, the main question here is whether you really need that mixture.
There's no such thing as "returning a pointer" by itself. You don't "return a pointer" just because you want to "return a pointer". Returning pointers is done for some specific reason and that reason will dictate how it is done and what needs to be done in order to ensure that it works properly.
Your original example does not really illustrate that since in your original example there's simply no meaningful reason to return a pointer. It looks like you can simply return an int.
For example, in many cases you'll want to return a pointer because it is a pointer to a dynamically allocated object, i.e. an object whose lifetime is not subject to scoping rules of the language. Note that the casual relationship in this case works in the opposite direction: you need a dynamic object -> you have to return a pointer. That way, not the other way around. In you example you seem to use it backwards: I want to return a pointer -> I have to allocate the object dynamically. That latter reasoning is fundamentally flawed, although one might see it used more often than one would expect.
If you really need a dynamically allocated object (for which, as I said above, the main reason is to override the scope-based lifetime rules of the language), then a matter of memory ownership becomes an issue. In order to know when this memory can/has to be deallocated and who has to deallocate it, you have to implement either exclusive (one designated owner at any moment) or shared (like reference counting) ownership scheme. It can be done with raw pointers, but a better idea would be to use various smart pointer classes provided by the libraries.
But in many situations you can also return pointers to non-dynamic objects (static or automatic), which is perfectly fine assuming that the lifetime of these pointers is the same or shorter than the lifetime of the objects they point to.
In other words, the reasoning behind the decision to return a pointer is not really different between C and C++. It is more design/intent-related than language-related. It is just that C++ provides you with more tools to make your life easier once you already decided to return a pointer. (Which sometimes works as incentive for C++ programmers to overuse concealed pointers).
In any case, again, this is an issue of what functionality you are trying to implement. Once you know that, you can make a good decision about whether you should "return a pointer" or not. And if you finally decided to return a pointer, it will help you to choose the proper return method. That's how it works. Trying to think about it backwards ("I just want to return a pointer, but I don't have a real reason for it yet") will only produce academically useless answers, each of which can be shown to be "wrong" in some specific circumstances.

Answer 5

As you suspected and others clarified, the first method is clearly wrong. Although C++ is a systems language and there are some circumstances where you might want do do this (it would return a particular, relative location on the stack, on most systems), it's ALMOST NEVER right. The second method is much more sane.
However, neither method should be encouraged in C++. One of the main points of C++ is that you now have references and exceptions rather than just the pointers of C. So what you do is return a reference, and allow new to throw an exception up the stack, if the memory allocation fails.

Answer 6

Don't forget to
delete
pointer after invocation of your method, which is correct.