Singleton implementation in Java vs C++

[Qunfeng Wang]

I talked Singleton with my friends yesterday:2 java programmers, 1 C++ programmer. We have three implementations.

java1

public class Singleton
{
    private static Singleton instance = new Singleton();
 
    private Singleton()
    {
    }
 
    public static Singleton getInstance()
    {
        return instance;
    }
 
    public static void main(String[] args)
    {
        System.out.println(getInstance());
        System.out.println(getInstance());
    }
}

I think this is dependent on Java language, when the class is loading, static instance will be initialized only once.

java2

public class Singleton
{
    private static Singleton instance;
 
    private Singleton()
    {
    }
 
    public static Singleton getInstance()
    {
        if(instance == null)
        {
            instance = new Singleton();
        }
        return instance;
    }
 
    public static void main(String[] args)
    {
        System.out.println(getInstance());
        System.out.println(getInstance());
    }
}

I think this implementation can work in any language.

C++1

public class Singleton
{
    static Singleton instance;
 
    private Singleton()
    {
    }
 
    public static Singleton getInstance()
    {
        instance = new Singleton();//Line 1
        return instance;
    }
 
    public static void main(String[] args)
    {
        System.out.println(getInstance());
        System.out.println(getInstance());
    }
}

It can work correctly in C++! But it's not the case in Java. Even we can replace Line 1 with "static Singleton instance = new Singleton();". It can still work in C++. I think it's must be the difference between static in Java and C++.

Do you think so? Then Why Java and C++ treat static in a different way? Which one is better?

Thanks.

[Stan James]

#1 is my personal favorite. #2 is fine if you synchronize the getInstance method to be thread safe. #3 you found does not work in Java. I don't know C++ enough to say much more than I'm surprised it works.

We never let a Singleton question go by without suggesting a careful review to make doubly sure it's the right solution. Singleton is overused and carries along a lot of limitations.

[Peer Reynders]

C++1 isn�t C++!

The canonical singleton implementation in C++ as described in GoF still remains:

// Singleton.hpp
 
class Singleton {
    public:
        static Singleton* Instance();
 
    protected:
        Singleton();
 
    private:
        static Singleton* _instance;
};
 
// Singleton.cpp
 
Singleton* Singleton::_instance = 0;
    
Singleton* Singleton::Instance () {
     if (_instance == 0) {
         _instance = new Singleton;
     }
     return _instance;
}

As to statics in C++. In Bjarne Stroustrup's The C++ Programming Langauge 3e p. 228 you see the following class declaration:

class Date {
    int d, m, y;
    [B]static Date default_date;[/B]
 
public:
    Date(int dd=0, int mm=0, int yy=0):
    //...
    static void set_default(int,int,int);
}

A class member defined in this way (i.e. static Date default_date) only has its memory allocated - and it is allocated in �static memory� (i.e. it doesn't come off the heap - in Java all objects are allocated from the heap). To initialize the object you need to additional action in the implementation file:

Date Date::default_date(16,12,1770); // Beethoven's Birthday
 
void Date::set_default( int d,int m,int y){
    Date::default_date = Date( d, m, y);
}

The static member is initialized by telling the Date constructor to initialize the memory of Date::default_date. Also note that

    Date::default_date = Date( d, m, y);

isn't a typo. There is no new. Essentially this runs the constructor straight over the existing memory of default_date. The standard syntax

    Date *pMyDate;
 
    pMyDate = new Date( d, m, y);

does two things:

Allocates memory for the object from the heap.

Initializes the memory to an object by running the constructor(s) over it.

So really the difference is that in C++ object memory can be allocated in "static memory", a stack frame, or from the heap (only objects allocated from the heap have to be de-allocated), while in Java all Objects are allocated from the heap.
[ June 01, 2007: Message edited by: Peer Reynders ]

[Qunfeng Wang]

I'm sorry I haven't the C++ code when I post this paste. Now I get it.

#include <stdlib.h>
#include "stdio.h"
 
class CSingleton
{
public:
static CSingleton* GetInstance();
private:
CSingleton() { m_count = 10; printf("m_count = %d\n", m_count); }
private:
int m_count;
};
 
CSingleton* CSingleton::GetInstance()
{
[B]static CSingleton *_myInstacne = new CSingleton;[/B] 
printf( "address = %d\n ", _myInstacne);
return _myInstacne;
}
 

int main()
{
printf("Hello world!\n");
CSingleton::GetInstance();
CSingleton::GetInstance();
return 1;
}
 

We invoke getInstance for two times and print the address for the object. They are same. If I write like this in Java, it will be two objects. As Peer said, the resason is C++ allocate memory for static object in static memory, but Java allocate it in heap. So my friend's implementation is right, although it's not appeared in GOF's book.

Stan,thanks for you suggestion. I see there is overuse of Singleton. And often see "Create Once" in this forum. But now we are just earning them one by one. So I want to totaly understand of them.

[Peer Reynders]

Originally posted by Louis Wang:
As Peer said, the resason is C++ allocate memory for static object in static memory, but Java allocate it in heap. So my friend's implementation is right, although it's not appeared in GOF's book.

Actually in the example you provided the Singleton object is allocated from the heap. new always allocates memory from the heap. What is in the program's static symbol table is the pointer _myInstance. This means that even though _myInstance looks like a local variable, it isn't actually on the method's stack frame. _myInstance persists outside of CSingleton::GetInstance but is only accessible inside CSingleton::GetInstance. That also means the line:

static CSingleton *_myInstacne = new CSingleton; 

executes exactly once - the first time CSingleton::GetInstance runs � after that it never runs again.

So basically this Singleton uses some of the dustier C/C++ features which the Java designers deliberately did not duplicate as they tend to obfuscate the overall intent. Personally I prefer the GoF version as it is clear in what it is trying to accomplish but I guess that is somewhat subjective.

[Ilja Preuss]

To reiterate with other words:

Java and C/C++ treat "static" differently in that C/C++ allows static local variables, which Java doesn't.

When I started working in Java, I actually missed static local variables quite a bit, but today I think in an OO language they are a code smell. I feel that they are an artefact of procedural thinking: they are basically a member variable that is only visible in one method, which means that the class is lacking cohesion.