Custom Object Factory

Question

My library uses the Object Factory technique to create "Nodes" that have a specific purpose. By default these Nodes do their job but are quite basic. I want to allow the users of my library to be able and create a sub-class of the provided "Node" class to define their own functionality while keeping the base functionality of a node intact. Here is some example code to demonstrate my question:

class Node
{
    int SomeValue;
public:
    Node(int Value)
    {
        SomeValue = Value;
    }

    ~Node()
    {
        // Cleanup the node
    }
};

class NodeFactory
{
    std::vector<Node*> Nodes;
public:
    void CreateNode(int Value)
    {
        Nodes.push_back(new Node(Value));
    }
};

This shows the basic Object Factory technique, now for my question. Can I add a function to the "NodeFactory" such as "void SetType()" and be able to pass in a sub-class of "Node" which in turn will have it create that sub-class during the "CreateNode" function?

Thank you very much for your time it is greatly appreciated.

EDIT:

The usage of "void CreateNode()" is abstracted away from the end user thus my curiosity towards a "void RegisterType()" function where the user can register their sub-class for the factory to create instead of the base-class I provide.

EDIT:

A more concise way to phrase the question would be as follows: How can I let the user tell the factory to create instances of their sub-class, if they've defined one, instead of my default base-class? I want to thank everyone again for their time and effort in answering this question.

Answer 1

I think the problem here is combining the following two requirements:

1. You want to use the quite simple function void CreateNode(int) to create any node.
2. You want the user to be able to create new nodes derived from Node and use your factory to create them.

Now what I would suggest is something similar to R Sahu however without following the Factory pattern as strictly as he did.

You could get the functionality you seek by requiring your users to pass a small Creator-object to your factory. (Note that this is deviating a bit from the classical Factory-pattern. As you basically make your NodeFactory into a delegator using the creator-classes.)

class NodeCreator {
public:
   virtual Node* create(int) = 0;
   virtual ~NodeCreator() = default;  
};

class DefaultNodeCreator : public NodeCreator {
public:
   virtual Node* create(int value) {
      return new Node(value);
   }
};

Now I as a user will create my own node:

class MyNode : public Node {
private:
   int otherValue;
public:
   MyNode(int nodeValue, int otherValue ) 
      : Node(nodeValue), otherValue(otherValue) 
   {}
   // Implement other functionality...
};

class MyNodeCreator : public NodeCreator { 
private:
   // I added otherNodeValue to show that Creators can have a state.
   int otherNodeValue; 
public:
   MyNodeCreator(int otherNodeValue ) : otherNodeValue(otherNodeValue) {}
   virtual Node* create(int value) {
      return new MyNode(value, otherNodeValue);
   }
};

Now finally in your Factory class you need to set it like this:

class NodeFactory
{
   std::vector<Node*> Nodes;
   std::unique_ptr<NodeCreator> activeCreator;

public:
   NodeFactory() {
      setNodeCreator(nullptr);
   }

   void createNode(int Value)
   {
       Nodes.push_back( activeCreator->create(Value) );
   }

   void setNodeCreator( std::unique_ptr<NodeCreator> creator ) {
      if (creator == nullptr) { 
         activeCreator.reset( new DefaultNodeCreator() );
      else {
         activeCreator.reset(creator);
      }
   }
};

To use it from main:

int main() {
   NodeFactory nf;

   nf.createNode(1); // Creating Node(1)
   nf.createNode(2); // Creating Node(2)

   nf.setCreator( new MyNodeCreator(5) );
   // Any nodes created now will be of type MyNode 
   // with otherNodeValue == 5.

   nf.createNode(2); // Creating MyNode(2, 5)
   nf.createNode(3); // Creating MyNode(3, 5)
}

A final note:

If you intend for your users to implement subclasses of Node and use these with polymorphism as shown above, it is important that you declare Node's destructor as virtual. You have no guarantee that your users will not use dynamic allocation in their subclasses, so it is your responsibility to ensure that their destructors get called.