Suppose we have to use a single object of a class throughout
the lifetime of an application. In C++, it is possible to declare a global object,
which can be used anywhere inside the program. But a good object
oriented design strictly prohibits the use of global variables or methods,
since they are against the fundamental principles of object orientation
like data encapsulation or data hiding. More over, most latest object oriented
programming languages like JAVA or C# do not support global variables or functions.
Another practical solution to get a single object is by declaring a
class, which contains only static methods. A static class is loaded into
memory when the execution of the program starts and it remains
there till the application ends. Remember that for invoking a
static method of a class, it is not necessary to create an instance
of the class. But remember that a class with only static methods and
variables are not a good object oriented design. A class of static methods
unfortunately breaks down to a list of functions or utilities.
When we want to create only one instance of a class
in a truly object oriented fashion by adhering to the basic
principles of object oriented programming, the Singleton patterns
are used. The Singleton Pattern comes under that classification of
Creational Pattern, which deals with the best ways to create objects.
The Singleton Design pattern is used, where only one instance of an object
is needed throughout the lifetime of an application. The Singleton class is
instantiated at the time of first access and same instance is used thereafter
till the application quits.
There are very good non-software examples available in real
world for Singleton patterns. The office of the Principal of my
college is a Singleton. The University specifies the means by
which a principal is selected, limits the term of office, and
defines the order of succession. As a result, there can be at
most one active principal at any given time. Regardless of the
personal identity of the principal, the title, "The Principal"
is a global point of access that identifies the person in the office.
The Singletons are often used to control access to
resources such as database connections or sockets.
Suppose we have a license for only one connection
for our database. A Singleton connection object makes
sure that only one connection can be made at any time.
It is pretty easy to implement the Singleton Pattern in
any object oriented programming languages like C++, JAVA or C#.
There are lots of different ways to implement the Singleton Pattern.
But by using a private constructor and a static method to create
and return an instance of the class is a popular way for implementing
Singleton Pattern. The UML representation of a Singleton Pattern is shown
using namespace std;
static bool instanceFlag;
static Singleton *single;
static Singleton* getInstance();
instanceFlag = false;
bool Singleton::instanceFlag = false;
Singleton* Singleton::single = NULL;
single = new Singleton();
instanceFlag = true;
cout << "Method of the singleton class" << endl;
sc1 = Singleton::getInstance();
sc2 = Singleton::getInstance();