Creational Design Patterns in Modern C++ - Introduction - introduces you to the pattern and its intent

The video discusses the prototype design pattern, a creational pattern that returns a clone of an existing instance rather than creating a new one. This approach is useful when object creation is expensive or when multiple instances with slight variations are needed. The pattern allows for controlled object creation and can be implemented even in languages that do not support runtime class specification. The intent is to create objects by copying a prototype, with classes inheriting from a base class that provides a clone method.

What is a key difference between the prototype design pattern and other creational patterns?

• It is not a creational pattern.

• It always creates a new instance.

• It clones an existing instance.

• It does not support object creation.

Why might one choose to clone an object instead of creating it from scratch?

• Creating from scratch can be expensive.

• Cloning is the only option in all languages.

• Cloning is always faster.

• Creating from scratch is always impossible.

How does the prototype pattern help in controlling object creation?

• By preventing any object creation.

• By allowing only one instance of a class.

• By using cloned instances from a prototype.

• By creating objects only at compile time.

What is required for a class to support cloning in the prototype pattern?

• It must be a final class.

• It must be a singleton.

• It must inherit from a common base class with a clone method.

• It must not have any methods.

How do clients typically use cloned instances in the prototype pattern?

• They use them polymorphically.

• They use them without any modification.

• They use them only for testing.

• They use them as static instances.