How to "return an object" in C++?

Question

I know the title sounds familiar as there are many similar questions, but I'm asking for a different aspect of the problem (I know the difference between having things on the stack and putting them on the heap).

In Java I can always return references to "local" objects

public Thing calculateThing() {     Thing thing = new Thing();     // do calculations and modify thing     return thing; } 

In C++, to do something similar I have 2 options

(1) I can use references whenever I need to "return" an object

void calculateThing(Thing& thing) {     // do calculations and modify thing } 

Then use it like this

Thing thing; calculateThing(thing); 

(2) Or I can return a pointer to a dynamically allocated object

Thing* calculateThing() {     Thing* thing(new Thing());     // do calculations and modify thing     return thing; } 

Then use it like this

Thing* thing = calculateThing(); delete thing; 

Using the first approach I won't have to free memory manually, but to me it makes the code difficult to read. The problem with the second approach is, I'll have to remember to delete thing;, which doesn't look quite nice. I don't want to return a copied value because it's inefficient (I think), so here come the questions

• Is there a third solution (that doesn't require copying the value)?
• Is there any problem if I stick to the first solution?
• When and why should I use the second solution?

Answer 1

I don't want to return a copied value because it's inefficient

Prove it.

Look up RVO and NRVO, and in C++0x move-semantics. In most cases in C++03, an out parameter is just a good way to make your code ugly, and in C++0x you'd actually be hurting yourself by using an out parameter.

Just write clean code, return by value. If performance is a problem, profile it (stop guessing), and find what you can do to fix it. It likely won't be returning things from functions.

---

That said, if you're dead set on writing like that, you'd probably want to do the out parameter. It avoids dynamic memory allocation, which is safer and generally faster. It does require you have some way to construct the object prior to calling the function, which doesn't always make sense for all objects.

If you want to use dynamic allocation, the least that can be done is put it in a smart pointer. (This should be done all the time anyway) Then you don't worry about deleting anything, things are exception-safe, etc. The only problem is it's likely slower than returning by value anyway!

Answer 2

Just create the object and return it

Thing calculateThing() {     Thing thing;     // do calculations and modify thing      return thing; } 

I think you'll do yourself a favor if you forget about optimization and just write readable code (you'll need to run a profiler later - but don't pre-optimize).