Thank you for your post, I found it to be very useful.
Just a doubt here, your code for the allocWithZone overriding is:

// We don’t want to allocate a new instance, so return the current one.
+ (id)allocWithZone:(NSZone*)zone {
return [[self sharedInstance] retain];
}

If sharedInstance is a static variable not bout to the class implementation (proof of that is you can declare it inside or outside the @implementation section), why use self? And, most important yet, why call retain on sharedInstance, since you also override the retain method to do nothing and just return self?

01
02
03
04
05
06
07
08
09
10
11
12
+ (SingletonClass *)sharedInstance {
if (nil != sharedInstance) {
return sharedInstance;
}

static dispatch_once_t pred; // Lock
dispatch_once(&pred, ^{ // This code is called at most once per app
singleton = [[SingletonClass alloc] init];
});

return singleton;
}

it should be

sharedInstance = [[SingletonClass alloc] init];
and return sharedInstance;

Also, why is it in this case we do not call the initWithZone() but the regular init()?

I have always declared my static variables just under the @implementation tag and never run into any problems before. I believe that the only variables you can declare within the @implementation section of a class are static variables (unless you use @implementation{ variables } construct – which is a relatively new feature I think). I’m fairly confident that declaring the static variable before or after the @implementation tag has exactly the same result and is simply down to style choice (I’ve seen both in libraries).

static SingletonClass *sharedInstance = nil;

Go before the @implementation tag? I don’t think you can declare any variables inside it.?

You call the sharedInstance. If it’s nil allocWithZone. Then in allocWithZone you return the sharedInstance, which requires calling sharedInstance. At this point it should still be nil so call allocWithZone…

And repeat until insane.

As we have overridden allocWithZone: calling [SingletonClass alloc] will in turn call allocWithZone:, which simply returns the one singleton copy of this object (by calling the +sharedInstance method). If the static object does not exist already, then it will be created during the alloc call and a reference to it returned. Either way, you are still providing access to the one and only singleton object that exists in memory. Therefore, calling [[SingletonClass alloc] init] will return the one single copy of this class (creating it if necessary) and then call the init method on that instance. It is the overridden allocWithZone method that ensures that another copy of this object is never created in memory.

If you are in a situation where you need to have a single copy of this class that is controlled and accessed by using [SingletonClass sharedInstance] but would also like to be able to create other copies of this class for other uses, then you can remove the methods allocWithZone:, copyWithZone, retain, retainCount, release, autorelease from the above code listing (basically, remove all methods except sharedInstance and init). This removes the restraint that only one copy of this class may ever exist, so only the one created by the sharedInstance method will be managed for you – you will have to memory manage all other copies of this class that you make yourself. Personally, i would err away from doing this, as I prefer to think that a class is either a Singleton or not (and not some strange hybrid), but the choice is yours!

With regards to your question, you don’t really need to treat your Singleton any differently to any other object. I’ve updated the example above to include a template ‘init’ method where you might want to include your normal initialisation-type code for this object. The init method will only be called once, and that will be just before the first time you get your hands on the singleton (the first time you call [SingletonClass sharedInstance]).

The only major caveat, is that you want to err away from init method that take parameters. As you’re not expected to care when / where your Singleton is initialised (it could be called anywhere in your code) it’s best to veer away from having any ‘initWith’ methods. It’s preferable to have a basic init method that sets up any required sub-objects and then you can configure those objects with additional instance methods on the singleton.

Hope this helps, if you have any further problems, or this isn’t very clear – please don’t hesitate to drop me another message.

Great stuff… I was wondering where I would initialize other objects within my singleton? Would you do it after the allocation of the shared instance or use “+initialize” ? Not sure what the “best practice” is…

if (sharedInstance == nil) {
sharedInstance = [[super allocWithZone:NULL] init];
/* WOULD I DO IT HERE */
}

I’m still a n00bie with Objective C so I apologize if the question is stupid.

Thanks,
Claudio

I could be wrong, but I’m pretty sure that copyWithZone should be an instance method (-) and not static (+). The method would normally be used to return a new instance that is a copy of the object that you call this method on. We simply return ‘self’ from the shared instance (you would call this [[SingletonObject sharedInstance] copyWithZone:zone]) as we don’t allow for more than one instance of the singleton to exist. See the NSCopying protocol for further details.

Thanks for the comment, I’m still learning a lot of this as I go – so it’s always interesting to talk over certain points.

I think this is wrong:

// Equally, we don’t want to generate multiple copies of the singleton.
- (id)copyWithZone:(NSZone *)zone {
return self;
}

it should be:

+ (id)copyWithZone:(NSZone *)zone {
return self;
};

However, will return self still works or do we need to call [self sharedInstance]?

Thanks,

I actually figured things out myself so no need to reply. This is what I ended up doing:

I added the following under the *.h:

NSString *general;

With a method as follows:

@property (nonatomic, copy) NSString *general;

I then added the following under the *.m:

@synthesize general;

Then I was able to get and set the saved global information by adding the following under the other object:

// set the value of the global “general” variable I created in the singleton class

-(IBAction) setValue:(id)sender {
[[GlobalsObject sharedInstance] setGeneral:@”test”];
}

// get the value of the global “general” variable that was set in the “setValue” action

-(IBAction) setTextValue:(id)sender {
barcode.text = [[GlobalsObject sharedInstance] general];
}

Thank you so much for posting this amazing tutorial. I am a brand new programmer and without this I would have never been able to complete my project. John Wordsworth, you are the man!

Nick

I’m sorry for the trouble but I’m a bit confused about the final use lines that you provided:

[sharedSingleton callAMethod];

With the “callAMethod” part, do we create a method in the singleton and set the data to it or am I losing something? I’m very new to this so I apologize for not being able to get my point across well. Thanks in advance.

Nick