Author image

Prototype Design Pattern


Implementing Prototype Design Pattern like a boss and then laughing it off.
Bonus: coool way of spawning arrays of objects from a prototypical instance (check spawnMonsterArray).

The prototype pattern is a creational software design pattern, that is used when the type of object(s) to create is determined by a prototypical instance, which is cloned to produce new objects. This pattern is used to:

  • avoid subclasses of an object creator, like the factory pattern does
  • avoid the inherent cost of creating a new object in the standard way (like using new) when it can be prohibitively expensive for a given application


  • define an abstract Prototype class with a clone() method that returns a copy of itself
  • create subclasses of Prototype . These will be the concrete types. Implement the clone method
  • create a Spawner/Factory class with a private Prototype pointer (sort of like the Queen bee who never leaves the hive) and a spawnObject() method. The Spawner class resembles a Prototype factory function. The spawnObject() method simply calls clone on its prototype object and returns it.
  • in the Spawner class call the prototype's clone method to return a copy of the prototype object based on the concrete subobject.

Notice there is a 1-to-1 relationship between a prototype and a factory/spawner. So create as many prototypical objects and their respective factory/spawner objects as the concrete subclasses you want to create.


  1. create the prototype(s): std::unique_ptr<Monster> skeletonPrototype = std::make_unique<Skeleton>();
  2. create the factory/spawner: std::unique_ptr<MonsterSpawner> skeletonFactory = std::make_unique<MonsterSpawner>( skeletonPrototype.get() );
  3. spawn a copy of the prototype object using the spawner: std::unique_ptr<Monster> skeleton = skeletonFactory->spawnMonster();
  4. or spawn multiple copies: auto skeletons = spawnMonsterArray<Skeleton>( skeletonFactory.get(), 10 );

The tricky aspect of this pattern in C++ is memory management & ownership of the objects. Thankfully, with C++11 onwards we have smart pointers and they can alleviate a large part of that burden. Still you have to make careful considerations concerning ownership. Create the prototypes as unique_ptrs, create the arrays/vectors as owners. On the other hand, the factories don't need to own anything, they simply make use of the passed pointer to do their thing. Give the code a careful read.

Prototype objects can be added and removed at run-time. One neat aspect about this pattern is that it doesn't just clone the class of the prototype, it clones its state too. This means we could make a spawner for fast ghosts, weak ghosts, or slow ghosts just by creating an appropriate prototype Ghost object.

I used Windows and Visual Studio 2017 to build the project.


Github repository link. Snag up the code now!