Download
1 / 6
60 likes | 230 Views
Creational Pattern: Singleton. Chapter 3 – Page 45. When an application needs one, and only one, instance of a particular object, proper enforcement of that object’s uniqueness and appropriate global access to the object can be problematic.
E N D
Creational Pattern: Singleton Chapter 3 – Page 45 When an application needs one, and only one, instance of a particular object, proper enforcement of that object’s uniqueness and appropriate global access to the object can be problematic. This is particularly useful when one object is needed to coordinate actions across a software system. One problem associated with this pattern is the fact that it complicates unit testing, since it introduces a global state into the software system.
The Singleton Pattern Chapter 3 – Page 46 The class of the single instance is responsible for access and "initialization on first use“. The single instance is a protected static attribute in order to guarantee that a new instance is created if one doesn’t already exist, and if one does exist, a reference to that instance is accessible. The constructor is private in order to ensure that the object can only be instantiated via the constructor.
C++ Code for a Logger Singleton Chapter 3 – Page 47 #include <string> #include <iostream> #include <fstream> #include <vector> using namespace std; class Logger { public: static const string kLogLevelDebug; static const string kLogLevelInfo; static const string kLogLevelError; // Returns a reference to the singleton Logger object static Logger& instance(); // Logs a single message at the given log level void log(const string &inMessage, const string &inLogLevel); // Logs a vector of messages at the given log level void log(const vector<string> &inMessages, const string& inLogLevel); protected: // Static variable for the one-and-only instance static Logger sInstance; // Constant for the file name static const char* constkLogFileName; // Data member for the output stream ofstreammOutputStream; private: Logger(); ~Logger(); };
const string Logger::kLogLevelDebug = "DEBUG"; const string Logger::kLogLevelInfo = "INFO"; const string Logger::kLogLevelError = "ERROR"; constchar* const Logger::kLogFileName = "log.txt"; // The static instance will be constructed when // the program starts and destroyed when it ends. Logger Logger::sInstance; Logger& Logger::instance() { returnsInstance; } Logger::~Logger() { mOutputStream.close(); } Logger::Logger() { mOutputStream.open(kLogFileName); if (!mOutputStream.good()) cerr << "Unable to initialize the Logger!" << endl; } void Logger::log(const string &inMessage, const string &inLogLevel) { mOutputStream << inLogLevel << ": " << inMessage << endl; } void Logger::log(const vector<string> &inMessages, const string &inLogLevel) { for (inti = 0; i < (int)inMessages.size(); i++) log(inMessages[i], inLogLevel); } Chapter 3 – Page 48
Chapter 3 – Page 49 void main() { Logger::instance().log("test message", Logger::kLogLevelDebug); vector<string> items; items.push_back("item1"); items.push_back("item2"); Logger::instance().log(items, Logger::kLogLevelError); }
Singleton Design Advantages Chapter 3 – Page 50 • The Singleton pattern ensures that the class (not the programmer) is responsible for the number of instances created. • Unlike static variables, the Singleton pattern is extensible, so if the software design later changes so a larger (but still controlled) number of instances is needed, only the instance() operator needs to be changed. • Unlike global variables, singletons don’t pollute the namespace with unnecessary variables.
