Creational Design Patterns in Modern C++ - Registry of Singletons - II

The video tutorial explains how to implement lazy instantiation for singletons using callbacks and shared pointers. It covers the transition from eager to lazy instantiation, the use of shared pointers for memory management, and the process of registering and retrieving printer instances. The tutorial also discusses modifying local printers to use shared pointers and tests the implementation. An alternative approach using the Meyers Singleton is briefly explored.

What is the main reason for using lazy instantiation over eager instantiation?

• To reduce memory usage by creating instances only when needed

• To ensure instances are created before the main function

• To increase the speed of instance creation

• To allow instances to be shared across different projects

How does the printer provider avoid tight coupling with printer classes?

• By implementing callback functions

• By storing raw pointers

• By using a single function for all operations

• By using eager instantiation

What is the role of shared pointers in the new implementation?

• To store raw pointers

• To manage memory manually

• To increase the complexity of the code

• To automatically manage memory and avoid manual deletion

What happens if a key is not found in the map during the get printer process?

• A new instance is created and added to the map

• The existing instance is returned

• The program crashes

• An unknown key message is printed and null is returned

Why is the register creator function important in the new implementation?

• It allows for the registration of eager instances

• It removes the need for shared pointers

• It ensures that creators are registered with a key

• It simplifies the get printer function

What is a key advantage of using the Meyers Singleton pattern?

• It allows for manual memory management

• It creates instances eagerly

• It requires complex setup

• It automatically destroys instances when the program terminates

What limitation does the Meyers Singleton pattern have?

• It creates instances before the main function

• It does not allow control over when instances are destroyed

• It cannot be used with shared pointers

• It requires manual memory management