Creational Design Patterns in Modern C++ - Registry of Singletons - Part I

The video tutorial discusses the violation of the dependency inversion principle and the need to refactor code to adhere to the open-closed principle. It introduces a Printer Provider class to manage Singleton instances, allowing for easier addition of new printer types without modifying existing code. The tutorial also covers the Multiton pattern, thread safety, and the differences between eager and lazy instantiation of Singletons.

What principle is violated when a Singleton class is tightly coupled with other parts of the program?

• Single Responsibility Principle

• Open/Closed Principle

• Dependency Inversion Principle

• Liskov Substitution Principle

What problem arises when a new printer class is added to the existing code?

• Violation of the Open/Closed Principle

• Decreased code readability

• Violation of the Single Responsibility Principle

• Increased code complexity

What is the purpose of the Printer Provider class?

• To manage multiple printer instances

• To enhance printer performance

• To create a mapping between keys and printer instances

• To simplify the printer class hierarchy

How does the Printer Provider class handle null pointers?

• By throwing an exception

• By returning a default printer instance

• By logging an error message

• By ignoring the null pointer

What is a Multiton?

• A class that provides thread safety for singletons

• A class that allows multiple singletons to be registered and accessed

• A class that manages multiple instances of a single class

• A class that enhances the performance of singletons

Why is thread safety important in the Printer Provider class?

• To prevent data corruption in multithreaded applications

• To improve the speed of printer operations

• To reduce memory usage

• To simplify the code structure

What is the disadvantage of eager instantiation in the context of singletons?

• It increases the complexity of the code

• It creates instances even if they are not used

• It makes the code less readable

• It violates the Open/Closed Principle