Question

In my application, there are 10-20 classes that are instantiated once[*]. Here’s an example:

class SomeOtherManager;  class SomeManagerClass { public:     SomeManagerClass(SomeOtherManager*);     virtual void someMethod1();     virtual void someMethod2(); }; 

Instances of the classes are contained in one object:

class TheManager { public:     virtual SomeManagerClass* someManagerClass() const;     virtual SomeOtherManager* someOtherManager() const;     /** More objects... up to 10-20 */ }; 

Currently TheManager uses the new operator in order to create objects.

My intention is to be able to replace, using plugins, the SomeManagerClass (or any other class) implementation with another one. In order to replace the implementation, 2 steps are needed:

1. Define a class DerivedSomeManagerClass, which inherits SomeManagerClass [plugin]
2. Create the new class (DerivedSomeManagerClass) instead of the default (SomeManagerClass) [application]

I guess I need some kind of object factory, but it should be fairly simple since there’s always only one type to create (the default implementation or the user implementation).

Any idea about how to design a simple factory like I just described? Consider the fact that there might be more classes in the future, so it should be easy to extend.

[*] I don’t care if it happens more than once.

Edit: Please note that there are more than two objects that are contained in TheManager.

Answer 1

I think there are two separate problems here.

One problem is: how does TheManager name the class that it has to create? It must keep some kind of pointer to ‘a way to create the class’. Possible solutions are:

• keeping a separate pointer for each kind of class, with a way to set it, but you already said that you don’t like this as it violates the DRY principle
• keeping some sort of table where the key is an enum or a string; in this case the setter is a single function with parameters (of course if the key is an enum you can use a vector instead of a map)

The other problem is: what is this ‘way to create a class’? Unfortunately we can’t store pointers to constructors directly, but we can:

• create, as others have pointed out, a factory for each class
• just add a static ‘create’ function for each class; if they keep a consistent signature, you can just use their pointers to functions

Templates can help in avoiding unnecessary code duplication in both cases.