Singelton design pattern

Question

0.00/5 (No votes)

See more:

while creating the singelton design pattern, how to restrict to create more than one object.
i have below code.

C#

#include<iostream.h>
class Singelton
{
    // Private Constructor
    Singelton()
    {
    }

    static Singelton *s_instance_p;

public:
~Singelton()
{


}
    static Singelton* get_instance();
    void method();
    static void DestroyInstance();
};
Singelton* Singelton::get_instance()
{

   return s_instance_p;

}
void Singelton::method()
{
    cout<<"Method function called"<<endl;
}
void Singelton::DestroyInstance()
{
    delete s_instance_p;
    s_instance_p = 0;
}
Singelton* Singelton::s_instance_p = NULL;

void main()
{
Singelton *ssl_ctu_ptr = Singelton::get_instance();
ssl_ctu_ptr->method();
Singelton *ssl_ctu_ptr1 = Singelton::get_instance();
ssl_ctu_ptr1->method();
//delete (ssl_ctu_ptr);//never call delete on the singleton pointer in main()
Singelton::DestroyInstance();
}

here i have created two instances ssl_ctu_ptr , ssl_ctu_ptr1.
Both are working fine. i am unable to understand how to restrict more than 1 instances.
please provide your solution
Thanks in Advance.

Posted 3-Feb-13 1:48am

ashu_1july

Add a Solution

3 solutions

Solution 3

Firstly, you have a spelling error... it is "Singleton".

Solution 2 is correct that you should check the static instance pointer and not a flag.

Neither of these choices is threadsafe. If you have more than one thread, you need to protect the first instance creation with a critical section.

Since the stated language desired is C++, you can define the static instance in the get_instance() method:

C++

Singelton* Singelton::get_instance()
{
    static Singelton* pThis;
    if(!pThis)
    {
        pThis = new Singelton();
    }
    return s_instance_p;
}

If the app is multithreaded, the 'if' statement needs to have critical section backup.

You can't use this technique in java or several other languages.

Posted 3-Feb-13 16:38pm

H.Brydon

Add a Solution

Add your solution here

Treat my content as plain text, not as HTML

Preview 0

…

Existing Members

Sign in to your account

...or Join us

Download, Vote, Comment, Publish.

Your Email
Password
Forgot your password?

Your Email
This email is in use. Do you need your password?
Optional Password

I have read and agree to the Terms of Service and Privacy Policy
Please subscribe me to the CodeProject newsletters

When answering a question please:

Read the question carefully.
Understand that English isn't everyone's first language so be lenient of bad spelling and grammar.
If a question is poorly phrased then either ask for clarification, ignore it, or edit the question and fix the problem. Insults are not welcome.
Don't tell someone to read the manual. Chances are they have and don't get it. Provide an answer or move on to the next question.

Let's work to help developers, not make them feel stupid.

This content, along with any associated source code and files, is licensed under The Code Project Open License (CPOL)

guna_sekar · Accepted Answer · 2013-02-03T03:50:00

Solution 2

Instead of having a flag we could also check whether the static instance is null and then create the singleton instance.

Posted 3-Feb-13 3:50am

guna_sekar

Muthuraja Irullandi · Accepted Answer · 2013-02-03T03:10:00

Hi,
You need to restrict in get_instance() method. Please find the below modified code.

C++

#include <iostream>
#include <conio.h>
 using namespace std;
 class Singelton
{
    // Private Constructor
    Singelton()
    {
    }
	static bool instanceFlag; //added
    static Singelton *s_instance_p;
 
public:
	~Singelton()
	{
 

	}
    static Singelton* get_instance();
    void method();
    static void DestroyInstance();
};

 bool Singelton::instanceFlag = false;
Singelton* Singelton::s_instance_p = NULL;

Singelton* Singelton::get_instance()
{
 
	if(! instanceFlag)
    {
        s_instance_p = new Singelton();
        instanceFlag = true;
        return s_instance_p;
    }
    else
    {
        return s_instance_p;
    }

}
void Singelton::method()
{
    cout<<"Method function called"<<endl;
}
void Singelton::DestroyInstance()
{
    delete s_instance_p;
    s_instance_p = 0;
}

int main()
{
	Singelton *ssl_ctu_ptr = Singelton::get_instance();
	ssl_ctu_ptr->method();
	
	Singelton *ssl_ctu_ptr1 = Singelton::get_instance();
	ssl_ctu_ptr1->method();
	
	//delete (ssl_ctu_ptr);//never call delete on the singleton pointer in main()
	Singelton::DestroyInstance();

	getch();
	return 0;
}
</conio.h></iostream>

In get_instance() method, we need to check whether the object is already created or not. if it is created then we need to return the object instead of creating new.

Hope this makes you understand!

Best Regards
Muthuraja