As I’ve been writing iPhone apps I’ve been using a variety of design patterns in my code. One of the most prevalent has been the use of singleton classes, which I’ve been using to store most of the data in my programs (I have found it much easier to access a singleton class than to pass around the object that stores all of my data).

The singleton design pattern is built into the iPhone SDK in a variety of places, most notably [UIApplication sharedApplication]. From this simple example, its not hard jump to the generic name sharedInstance that Apple uses for its singleton classes.

I’ll show you how to make a very simple singleton class, which I call SampleSingleton. You can also find the following code in a corresponding .h and .m at the end of this post.

To create a singleton class, you should have the following line of code in your .h file.

+ (SampleSingleton *)sharedInstance;

Now that little plus sign is what’s really important here. We are defining a Class Method, which many refer to as a ‘Factory Method’. This is because calling a method with a + in front of it will usually create an instance of that class. In this case, because we are using the singleton design pattern, it will only create an instance the first time the method is called. Every other time it will return that same instance.

For the .m we have to add the following line before the @implementation:

static SampleSingleton *sharedSampleSingletonDelegate = nil;

This will allow the SampleSingleton to hold on to itself once it has been allocated.

Next we have to define the sharedInstance function:

+ (SampleSingleton *)sharedInstance {
   @synchronized(self) {
      if (sharedSampleSingletonDelegate == nil) {
         [[self alloc] init]; // assignment not done here
      }
   }
   return sharedSampleSingletonDelegate;
}

Notice that this function does not change the sharedSampleSingletonDelegate variable. That will be done in another function.

Finally we have to define whole slew of other functions in the .m, mostly overriding functions of the NSObject class that would usually allow an object to be deallocated, but it also includes functions related to allocating and copying the object.

+ (id)allocWithZone:(NSZone *)zone {
   @synchronized(self) {
      if (sharedSampleSingletonDelegate == nil) {
         sharedSampleSingletonDelegate = [super allocWithZone:zone];
         // assignment and return on first allocation
         return sharedSampleSingletonDelegate;
      }
   }
   // on subsequent allocation attempts return nil
   return nil;
}

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

- (id)retain {
   return self;
}

- (unsigned)retainCount {
   return UINT_MAX;  // denotes an object that cannot be released
}

- (void)release {
   //do nothing
}

- (id)autorelease {
   return self;
}

It is extremely important to define all of the one line functions, but the most important function here is likely the allocWithZone: function. Its job is to set sharedSampleSingletonDelegate and ensure that no other instance of our SampleSingelton can be allocated, ensuring a singleton.

Thats it. For your own code, you can simply use the attached .h and .m files to start your own singleton class, or just copy-paste what I’ve written here (both are exactly the same). I’ll talk more about how I use singleton’s in another post, and I’ll likely do a quick post on the Refactor tool in XCode which will greatly simplify the use of the attached files by allowing you to simply rename all instances of SampleSingleton to whatever you might want to call your class.

samplesingleton.h samplesingleton.m