Public scope in Objective-C?

Question

Hi there!

I’m sure this is a simple one, but it’s been elusive so far, and I’m stumped ...

How do I declare an Ivar so that it’s accessible from ALL Classes in a project?

[Don’t know if it matters, but the ivar in question is (an instance of) my Model class, whose data needs to be accessible to various view controllers.]

Best as I can tell from "The Scope of Instance Variables” in The Objective-C 2.0 Programming Language ... this would be by using the “@public” directive.

So I’ve tried this in the @interface block where the ivar is declared:

@interface ...

...

@public
ModelClass *theModel;

@end

... But when I try to refer to “theModel” in a different class, the compiler doesn’t auto-complete, and when I type it in anyway, the compiler shows: “Error: ‘theModel’ undeclared (first use in this function)”.

I assume this is a question of Scope, and that I haven’t made the ivar available appropriately, but how? Somehow I need to access this, or make its pointer available somehow.

Any ideas would be VERY much appreciated. Many thanks!

Answer 1

You cannot access iVars from any other class.

You have to declare a getter/setter method to change or view a variable from another class - what you are really looking for are properties, that make it easier to define and access these getter/setter methods.

In your example above, you'd have the property defined just after the block that defines the local variable in the header file:

@property (nonatomic, retain) ModelClass *theModel;

In the implementation file you'd have the getter/setter created with the @synthesize statement just after the @implementation line:

@synthesize theModel;

Then if you have an instance of your class created, you access the class instance variable like so:

myInstance.theModel = [[[ModelClass alloc] init] autorelease];

The reason @public & @private are in there are to define visibility for subclasses (which, being extensions of that class type also get all the class local variables defined by a superclass), not for any random class.

Answer 2

Think a C global variable.

Adding:
extern ModelClass* theModel;
after the @end in the header will make the variable visible anywhere you include the header.

In the ModelClass.cpp file add:
ModelClass* theModel;
before the class implementation.

The variable will still have a value of nil until you allocate and initialize it though and you will be resposible for ensuring that it gets deallocated at the correct time.

Answer 3

The standard Objective-C way of doing it is to have a class method that returns the ivar

In your .h file:

+ (id)defaultModel;

and in your .m file:

static ModelClass * defaultModelInstance;

@implementation ModelClass

+ (id)defaultModel {
    if (!defaultModelInstance) {
        defaultModelInstance = [[ModelClass alloc] init];
    }
    return defaultModelInstance;
}

@end

although this will need tweaking if you need a specific ivar instead of just "a ivar that's always the same"

this type of design is used by many Cocoa classes i.e. [NSWorkspace sharedWorkspace]

Answer 4

Perhaps you forgot to put the instance variable inside the braces of the class where all instance variable declarations go?

@interface Foo : NSObject {

    // other instance variable declarations

    @public
    ModelClass *theModel;
}

// method and property declarations

@end

Also, can you show us the code of how you are trying to access the instance variable from elsewhere? The proper syntax should be:

myFooInstance->theModel

where myFooInstance is a value of type "Foo *"

Answer 5

I make properties available to all views managed by a Tab Bar via a singleton representing my data model. This is efficient and allows all Views access to the data (as well as any other application elements. Creating the singleton is straightforward (there are a ton of examples on S.O.). The you just request the instance and get the property values you need.

Here is a framework fro creating the Singleton. The key points are the static instance and the fact that you do the initialization as [[self alloc] init];. This will ensure the object gets cleaned up correctly. All the methods at the bottom of the class are standard from the SDK Docs to make sure release calls are ignored (because the object is shared globally).

Singleton Boilerplate (ApplicationSettings.m):

static ApplicationSettings *sharedApplicationSettings = nil;

+ (ApplicationSettings*) getSharedApplicationSettings
{
    @synchronized(self) {
        if (sharedApplicationSettings == nil) {
            [[self alloc] init]; // assignment not done here
        }
    }
    return sharedApplicationSettings;
}

+ (id)allocWithZone:(NSZone *)zone
{
    @synchronized(self) {
        if (sharedApplicationSettings == nil) {
            sharedApplicationSettings = [super allocWithZone:zone];
            return sharedApplicationSettings;  // assignment and return on first allocation
        }
    }
    return nil; //on subsequent allocation attempts 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;
}

Answer 6

THANK YOU ALL for the very helpful discussion on this topic! Clearly there are several ways to approach things here, so this is a very useful assortment of techniques.

Just to let y'all know that in researching this issue further, I ran across a couple of other very helpful pages, listed below. They include mention of the NSNotificationCenter, which I hadn't heard of before; as well as the idea of the "dependency injection" design pattern.

The idea is to keep "low coupling"(1) between the classes, making the code more modular & better for unit testing.

And while the 'notification' pattern sounds like a great idea, in this case it may be a bit overkill, considering that I only need ONE instance of the data model throughout the run of the app, and it doesn't change throughout.

Finally, even though the "@public" compiler directive is well-documented in Apple's Obj-C guide(2), I later found a fascinating edict in a different doc stating that it shouldn't be used! Quoted from Apple's own Cocoa Fundamentals(3):
"Give the proper scope to your instance variables. Never scope a variable as @public as this violates the principle of encapsulation. ..."
(Strange that they don't mention this in their 'Objective-C 2.0' guide where the directive is actually explained.)

Anyway, here are a couple of other links I found to be full of some great insights as well. FYI:

• S.O.: "What’s the best way to communicate between viewcontrollers?"(4) <<

• CocoaWithLove: "Five approaches to listening, observing and notifying in Cocoa"(5)

• CocoaWithLove: "Singletons, AppDelegates and top-level data"(6)

Hope these help. Anyway, thank you all again!

Best, rond

P.S. Yikes! It won't let me post more than one inline hyperlink, so I'm listing them here instead. Obviously, they’re all prefixed by “http://” ... :O

(1): en.wikipedia.org/wiki/Coupling_(computer_science)
(2): developer.apple.com/DOCUMENTATION/Cocoa/Conceptual/ObjectiveC/Articles/ocDefiningClasses.html#//apple%5Fref/doc/uid/TP30001163-CH12-TPXREF127
(3): developer.apple.com/documentation/Cocoa/Conceptual/CocoaFundamentals/AddingBehaviortoaCocoaProgram/AddingBehaviorCocoa.html#//apple_ref/doc/uid/TP40002974-CH5-SW12
(4): stackoverflow.com/questions/569940/whats-the-best-way-to-communicate-between-viewcontrollers
(5): cocoawithlove.com/2008/06/five-approaches-to-listening-observing.html
(6): cocoawithlove.com/2008/11/singletons-appdelegates-and-top-level.html