Custom Class Won't Respond to Method?

You want

Code:

PolygonShape *test = [[PolygonShape alloc] initWithNumberOfSides....]

 

1. You are trying to call a class method of class PolygonShape. That's what the warning says very clearly: "+" is for class methods, "-" is for instance methods.

2. Your init method ends up calling [super init] twice, once directly, once indirectly. That's asking for trouble.

 

alloc is a class method, which you probably will rarely need to override. init... methods are instance methods, which you will often override.

The alloc & init combination is very common. You tell the PolygonShape class to allocate a new PolygonShape object; and then calling the initWithNumberOfSides... method of that object to initialise it. The alloc class method won't refer to any instance variables, the init... instance method most likely will.

 

In nearly all of the normal cases you should never call -dealloc. This is called by the system when either the GC is triggered or the retain count hits 0. Calling -dealloc before this point will cause undefined behavior. Either use the GC behavior or the retain/release method of maintaining objects.

The correct way of handing polygonArray is:

Code:

NSMutableArray *polygonArray = [[NSMutableArray alloc] init];    
    [polygonArray addObject:[[PolygonShape alloc] initWithNumberOfSides:4
                               minimumNumberOfSides:3
                               maximumNumberOfSides:7]];
// I do some stuff with it in the middle, then I'm done with it...
    for (PolygonShape *shape in polygonArray)
    {
        //[shape dealloc];
        [shape release];
    }    
    //[polygonArray dealloc];
    [polygonArray release];

 

This code is definitely wrong. First, you should never call dealloc on any object, unless it's [super dealloc] in that object's own dealloc implementation. When you directly call dealloc, you are circumventing the retain/release mechanism, and grave disorder may ensue when you least expect it.

For your polygonArray, you should do two things:
1. simply release it when you're done with it.
2. call release on each PolygonShape after it's been added.

#1 is needed because you own the array.

#2 is necessary because you own each PolygonShape you added to the array. When each item was added, the array itself also called retain, so it's also claiming ownership. If you release the array, then it relinquishes ownership by calling release on each item, but you still have ownership of each shape added. So, if you release after the shape is added, you relinquish your ownership, and the only remaining owner is the array. Then when you release the array, it releases all its items, so everything is now ownerless, and its memory is deallocated.


As to your implementation of dealloc in PolygonShape, if all you're doing is [super dealloc], then you don't need to override the default. That is, if weren't for the NSLog call, you wouldn't even have to implement dealloc, because the inherited method (which is the one invoked by [super dealloc]) would already be correct and complete.

However, if PolygonShape has instance variables that are objects owned by that instance of PolygonShape, then dealloc must do two things: release all its owned objects, then call [super dealloc].


You should read and re-read the Cocoa Memory Management Guide until the rules are burned into your memory, and until the above explanation becomes blindingly obvious. That guide discusses the rules of ownership, and also discusses how and why to implement dealloc.

 

A couple of comments:

- You alloc..init.. your PolygonShape and add it to the array all in one line. This isn't "wrong", but could present a potential problem, if garbage collection is off. alloc sets the reference count to 1, addObject: increments it again so you'd actually need to release the object twice or it'll leak.

I'd recommend splitting into separate lines:

Code:

NSMutableArray *polygonArray = [[NSMutableArray alloc] init];	
PolygonShape* myShape = [[PolygonShape alloc] initWithNumberOfSides:4
						       minimumNumberOfSides:3
						       maximumNumberOfSides:7];
[polygonArray addObject: myShape];
[myShape release]; // This is ok! addObject: has already retained the object.

- More importantly, don't call dealloc! You should call release instead. Dealloc deletes the object immediately, whereas release will call dealloc if nothing else is referring to it. If you call dealloc directly, you risk leaving dangling pointers which would likely cause a crash if de-referenced.

You can just call removeAllObjects to clear the array (and send each item a release), and release the array itself.

 

You didn't post the source of PolygonShape.h, so no one knows the instance variables but you. Before posting the source and believing what we tell you, though, try working it out by yourself.

First consider whether the instance variables are object references or whether they're basic C types like int, double, or float?

Only objects can be sent messages, so if you're trying to send a message to an int or float, then you probably need to re-read the part about basic types vs. objects. Basic types may also be called simple types, primitive types, intrinsic types, fundamental types, etc. Objects may be called objects, object pointers, object references. etc. Terminology depends on which book or reference you're reading, and you haven't said what that is yet.