How to return references to object created inside a method

Question

I am reasoning about the best approach to return references to objects created inside a method, like in the following situation:

class A{
public:
    A(){}
    ~A(){}
};

class Foo{
public:
    Foo(){}
    ~Foo(){}
    A& create(int random_arg){
         // create object A and return its reference
    }
};

void other_method(){
     Foo f;
     A a = f.create();
     // do stuff with a
{

I have considered three possible solutions:

1. create a raw pointer and return a reference, but this is bad because there is no guarantee that the object will be properly deleted:

   A& create(int random_arg){
        A* a = new A();
        return *a;
   }
   

2. create a shared_ptr and return the shared_ptr by value. In this way the shared_ptr will take care of the object deletion:

   shared_ptr<A> create(int random_arg){
        boost::shared_ptr<A> a_ptr(new A());
        return a_ptr;
   }
   

3. create a shared_ptr and return a reference:

   A& create(int random_arg){
        boost::shared_ptr<A> a_ptr(new A());
        return *a_ptr;
   }
   

The second solution seems to be the most used, but in this way I have to spread shared_ptr in the application and I would prefer to have references, or better const references.

What do you think is the best way to handle this situation? Are there other possibilities I have not considered?

Answer 1

Don't do this. You're most likely to have a dangling reference.

Just return the instance of A by value instead.

It's likely that the compiler will elide the implied object copy. But you can guarantee that an object copy will not be made by writing a move constructor for A.

Answer 2

To complete Bathsheba's answer:

There is only one case where you might want to do something like that, that is if you are returning an instance to a singleton. In this case such instance will be a static object:

A& getTheOnlyInstanceOfA()
{
   static A onlyInstOfA;
   return onlyInstOfA; 
}