Question

Consider this code:

+(id)sharedInstance
{
    static dispatch_once_t pred;
    static MyClass *sharedInstance = nil;
    dispatch_once(&pred, ^{
        sharedInstance = [[MyClass alloc] init];
    });
    return sharedInstance;
}

If I follow this singleton design pattern I can make the following assumptions:

• The allocation and initialization will only be executed once thanks
  to GCD.
• The sharedInstance class variable can only be accessed from
  within this implementation and shared among the class regardless of the instance.

First time I create the instance I would do something like:

MyClass *something = [MyClass sharedInstance];

my question is, If I call the previews code again but like this:

MyClass *somethingOther = [MyClass sharedInstance];

I can only think of one outcome.

Outcome:

static MyClass *sharedInstance = nil;

Makes sharedInstance class variable point to nil and a nil is returned so somethingOther will be nil.

But I thought that what was supposed to happen in a singleton is that the shared instance would be returned instead.

Now consider this code:

+ (MotionManagerSingleton*)sharedInstance {

    static MotionManagerSingleton *_sharedInstance;
    if(!_sharedInstance) {
        static dispatch_once_t oncePredicate;
        dispatch_once(&oncePredicate, ^{
            _sharedInstance = [[super allocWithZone:nil] init];
            });
    }

    return _sharedInstance;
}

+ (id)allocWithZone:(NSZone *)zone {    

    return [self sharedInstance];
}

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

Here the

static MotionManagerSingleton *_sharedInstance;

Doesnt set my variable to nil, but i thought that all object pointers are initialized to nil by default.

My question is, how are these class methods returning the “sharedInstance”?

Thanks

Answer 1

One. Non-initialized pointers are non-initialized.

static MotionManagerSingleton *_sharedInstance;

won’t make your MotionManagerSingleton point to nil. It will point to an undefined (garbage) location.

Two. Variables declared static are initialized only once (yes, the syntax is a bit inconsistent with the semantics), so your first implementation won’t null out the returned shared instance. That’s a perfectly fine implementation.