Objective-C - Where are class instances declared?

Question

I'm making a program using Objective-C (Xcode) and I need to be able to make an instance of another class.

- (void)viewDidLoad {
    [super viewDidLoad];
    currentSide = 0;
    [self loadStage];
    Cube *cube = [[Cube alloc] init];
}

I wanted to make an instance of Cube as soon as the first Viewcontroller loads, but when I make it there, no other methods can access it.

I'm brand new to Obj-C but as I understand it, Viewcontroller.m should not have a main method in it, as this is in the main.m file. So where should class instances be made?

I bet I'm missing something obvious. Thanks in advance.

Answer 1

If you just want a simple ivar, instead of a property, you simply want to define it in your @implementation { ... }.

There's simply no need for it to be in the @interface as this exposes your class's inner workings to other classes. See this amazingly detailed answer for more info.

Example of ivar usage:

@implementation YourViewController {
    Cube *cube;
}

You can then load this in from your viewDidLoad:

- (void)viewDidLoad {
    [super viewDidLoad];
    currentSide = 0;
    [self loadStage];
    cube = [[Cube alloc] init];
}

And can freely access it throughout your class:

-(void) foo {
    cube.bar = @"baz";
}

I prefer ivars over properties for something like this (internal variables) for a few reasons:

• If you aren't using any getters or setters, why overlay an extra layer over the ivar if you're not going to use it? (that's all properties are at the end of the day).

• They're much cleaner to use in your class (cube instead of self.cube).

• They're much quicker to define.

• They're much easier to distinguish from external properties (I like to keep external values and internal values separated).

• They're faster. Okay, only by a couple of nanoseconds, but every little counts.

Although, it's worth noting that properties are better than ivars (for internal storage) in some situations:

• If you want to make your code thread safe, you should be using atomic properties in order to ensure that read & writes are serialised correctly.

• If you want to use internal getters and setters (I have never needed to do this, but it's there if you want).

• If you want to use KVO (although, again I've never needed to this internally).

At the end of the day, it's still a matter of preference. I am aware that I was maybe a little too sledge-hammer-y in asserting that ivars are better than properties in some of the comments I made.

Answer 2

I would do it like this, in your .m file:

  @interface YourClass () 

  @property(nonatomic, strong) Cube cube;

  @end

  @implementation YourClass

  - (void)viewDidLoad {
    [super viewDidLoad];
    currentSide = 0;
    [self loadStage];
    self.cube = [[Cube alloc] init];
  }

  @end

You don't have to use the @property syntax, but it's the standard convention, makes your code easier to read, allows you to have a getter or setter later if you so need it, and easily allows you to specify how ARC should treat the object.

Answer 3

you can do a lazy initialization.

Declare Cube first as a class property variable. (in your .m file)

@property Cube *cube;

then override the getter method of cube like this

- (Cube *)cube
{
   if(!_cube) {
      _cube = [[Cube alloc] init];
   }
   return _cube;
}

then to use the object in any method of your class

[self.cube anyMethodOfCube];

Answer 4

define your object in interface as:

@implementation YourViewController
{
  Cube *cube;
}

and initialize in first use or directly in viewDidLoad:

cube = [[Cube alloc] init];

-(void)someOtherMethodInViewController
{
      [cube cubeMethod];//now it is reachable
}

EDIT as originaluser2 stated in comment, there is a detailed explanation for the case. but for improving the answer i changed according to that link.