Question

Suppose I have some kind of factory function which creates objects that are largely used for a very short timespan only (possibly just for the duration of the scope of the function where this factory function is called).

Like this:

foo factory(some_parameter fancy_parameter)
{
   return foo(fancy_parameter);
}

//this gets called all the time... very often
void every_frame_function()
{
   for(int i=0; i<big_number; ++i)
       do_something_with(factory(some_parameter(i));

} //don't need those foos out here!

Is there a way to implement such factories without having the user care about memory management (by returning a pointer), without having to deal with smartpointer overhead and without returning a foo object that has to be hardcopied?

Maybe I’m asking for a goose that lays golden eggs here, but maybe there are some move semantics to be used here (I just don’t know how).

Answer 1

Use std::unique_ptr<T>, it has zero overhead compared with a raw pointer.

Or simply return by value, but then you cannot do subtype polymorphism.