{"id":6454,"date":"2022-10-02T15:08:59","date_gmt":"2022-10-02T15:08:59","guid":{"rendered":"https:\/\/www.modernescpp.com\/index.php\/the-singleton-the-alternatives\/"},"modified":"2023-06-26T08:58:21","modified_gmt":"2023-06-26T08:58:21","slug":"the-singleton-the-alternatives","status":"publish","type":"post","link":"https:\/\/www.modernescpp.com\/index.php\/the-singleton-the-alternatives\/","title":{"rendered":"The Singleton: The Alternatives Monostate Pattern and Dependency Injection"},"content":{"rendered":"

So far, I have discussed in my previous posts the Singleton Pattern, and its pros and cons. One question is still open: What alternatives for the Singleton Pattern are available? Today, I write about the Monostate Pattern and Dependency Injection.<\/p>\n

<\/p>\n

 \"CreationalPatterns\"<\/p>\n

I want to start this post with the Monostate Pattern.<\/p>\n

The Monostate Pattern<\/h2>\n

The Monostate Pattern<\/a> is similar to the Singleton Pattern and quite popular in Python. While the Singleton Pattern guarantees that only one instance of a class exists, the Monostate Pattern ensures that all instances of a class share the same state. The Monostate Pattern is also known as Borgidiom, because the Borgs<\/a> in the Star Trek series share a common memory.<\/p>\n

In the Monostate Pattern, all data members are static<\/code>. Consequentially, all instances of the class use the same data. The member function to access the data are non-static<\/code>. Users of the instances are unaware of the singleton-like behavior of the class.<\/p>\n

<\/p>\n

\n
\/\/ monostate.cpp<\/span>\r\n\r\n#include <iostream><\/span>\r\n#include <string><\/span>\r\n#include <unordered_map><\/span>\r\n\r\nclass<\/span> Monostate<\/span> {\r\n  \r\n public:<\/span>\r\n    \r\n    void<\/span> addNumber(const<\/span> std::<\/span>string&<\/span> na, int<\/span> numb) {\r\n        teleBook[na] =<\/span> numb;\r\n    }\r\n \r\n    void<\/span> getEntries () const<\/span> {\r\n        for<\/span> (auto<\/span> ent:<\/span> teleBook){ \r\n            std::<\/span>cout <<<\/span> ent.first <<<\/span> \": \"<\/span> <<<\/span> ent.second <<<\/span> '\\n'<\/span>;\r\n        }\r\n    }\r\n    \r\nprivate:<\/span>\r\n    static<\/span> std::<\/span>unordered_map<<\/span>std::<\/span>string, int<\/span>><\/span> teleBook;\r\n \r\n};\r\n\r\nstd::<\/span>unordered_map<<\/span>std::<\/span>string, int<\/span>><\/span> Monostate::<\/span>teleBook{};\r\n\r\nint<\/span> main<\/span>() {\r\n    \r\n    std::<\/span>cout <<<\/span> '\\n'<\/span>;\r\n    \r\n    Monostate tele1;\r\n    Monostate tele2;\r\n    tele1.addNumber(\"grimm\"<\/span>, 123<\/span>);\r\n    tele2.addNumber(\"huber\"<\/span>, 456<\/span>);\r\n    tele1.addNumber(\"smith\"<\/span>, 789<\/span>);\r\n    \r\n    tele1.getEntries();\r\n    \r\n    std::<\/span>cout <<<\/span> '\\n'<\/span>;\r\n    \r\n    tele2.getEntries();\r\n    \r\n    std::<\/span>cout <<<\/span> '\\n'<\/span>;\r\n    \r\n}\r\n<\/pre>\n<\/div>\n
 <\/p>\n
Each instance of the class Monostate<\/code> shares the same state:<\/p>\n
\"monostate\"<\/p>\n
 <\/p>\n
You probably think about Dependency Injection in the first place when you search for the alternative for the Singleton Pattern.<\/p>\n<\/p>\n
Dependency Injection<\/h2>\n
The Singleton Pattern has serious drawbacks that I described in the previous post “The Singleton: Pros and Cons”, Consequentially, the Singleton Pattern would probably not be part of a reprint of the book “Design Patterns: Elements of Reusable Object-Oriented Software”<\/a>. Instead, Dependency Injection is a highly likely future candidate.<\/p>\n
The key idea of Dependency Injection is that an object or function (client) receives the other service it depends on. Therefore, the client is not aware of the construction of the service. The client is fully separated from the service that is injected by an injector. This is in contrast to the Singleton Pattern, where the client creates the service if needed.<\/p>\n
<\/p>\n
\n
int<\/span> client<\/span>(){\r\n  \r\n  ...\r\n\r\n  auto<\/span> singleton =<\/span> Singleton::<\/span>getInstance();\r\n  singleton.doSomething();\r\n\r\n  ...\r\n\r\n}\r\n<\/pre>\n<\/div>\n
 <\/p>\n
Dependency Injection is a form of inversion of control.<\/a> Not the client creates and calls the service, but the injector injects the service into the client.<\/p>\n
In C++, three types of Dependency Injection are typically used:<\/p>\n