Where to delete an object created by factory?

Question

If I have a factory, that creates an object and returns a pointer to it, what will be a better way to delete it:

By delete call in the "user" code, or by a new DestructObject function which I should have together with the factory?

Answer 1

In the general case, the factory might not use plain old new to allocate the object. It may use object and/or page pooling, malloc with placement new, or something even more exotic (memory mapping?). There are at least three ways to handle this that I can think of:

1. Have the factory supply a recycle method to be called when you are done with the object.
2. Return a smart pointer that knows how to do away with the object once no referers remain.
3. Implement a custom delete operator in the object itself.

I hesitate to recommend one over the other, since I haven't given it enough thought in the last five minutes to proffer a definitive opinion, but I would tend to favour the last option in combination with a regular smart pointer like boost/tr1::shared_ptr.

Answer 2

The best way to delete it manually would be not at all.

Answer 3

The most versatile solution for this problem is to derive your class from a base class that has a virtual "killing" function. Something like this:

class IDisposable {
public:
    virtual void Release() = 0;
};

It's generally believed that polymorphic objects should have virtual destructors to support proper object cleanup. However this is incomplete, because it doesn't account for potentially different memory management of objects.

On the other hand this method doesn't require to use virtual destructors. It's now replaced by Release function that does both: invokation of the correct destructor and releasing the memory by the appropriate means.

takes care of the object destr

both: destruct

The object returned from the factory will implement this "interface".

Answer 4

The following code provides an opportunity not to think about who should remove the newly created object.

class FooFactory
{
public:
    static std::auto_ptr<Foo> CreateInstance();
};

// transmit ownership of created object from factory to 'a' variable
std::auto_ptr<Foo> a = FooFactory::CreateInstance();
// using the created object is not required
FooFactory::CreateInstance();