为什么我们可以在方法的实现中使用自定义/基础类的实例而无需先对该实例进行alloc和init？

Question

This question is based on the code from the first lecture in the Stanford iOS series 2014 (objective - c).

We created a class called Card which includes a method named match: which will be used to determine how different cards will match up against one another in the game, and this method takes as an argument an NSArray called *otherCards and we use an instance of Card called *card to iterate through this array in the implementation of this method.

My question is this - how can we just declare an instance of our class Card ie *card and use it as an iterating variable in the for loop without first allocating and instantiating it? In the same vein, how can we just declare *otherCards as an instance of NSArray and then use it in the cycling through of the for loop before it is allocated and initialised also?

I realise this might be done later in the code, but why isn't the compiler throwing at least a warning about this?

Here is the code:

//Card.h

@interface Card : NSObject

@property (strong, nonatomic) NSString *contents; 
@property (nonatomic, getter=isChosen) BOOL chosen;
@property (nonatomic, getter=isMatched) BOOL matched;

- (int)match:(NSArray *)otherCards;



    //Card.m

  #import "Card.h"

    @implementation Card
    - (int)match:(NSArray *)otherCards
    {


        int score = 0; 
    for (Card *card in otherCards) { 
    if ([card.contents isEqualToString:self.contents ])
    {
            score = 1;
        }

        }

        return score;
    }


    @end

Answer 1

I think your question is about this loop:

for (Card *card in otherCards) {
    ...
}

how can we just declare *otherCards as an instance of NSArray and then use it

You don't need to alloc and init otherCards because it is supplied as a parameter to the function match . The caller is responsible for initializing it. You can't dodge initialization, just that it's done elsewhere:

Card * myCard = ...               // init the varible here
NSArray * otherCards = ...        // init the array here
int n = [myCard match:otherCards] // otherCards is now initialized. Don't need to 
                                  // do it again inside your method

how can we just declare an instance of our class Card ie *card and use it as an iterating variable in the for loop

card is not a new object. It just points existing objects inside the otherCards array, hence no need to alloc and init.

You did declare card as a pointer of type Card in the for loop: for (Card * card in otherCards) . This is a syntactic sugar to make code more concise. You can do it the long way if you want:

Card * card;
for (card in otherCards) {
    // do something
}

Answer 2

…(NSArray *)otherCards and Card *card in are both placeholders.

otherCards is a parameter name. The method match expects an (initialized) NSArray as parameter to process the array locally in the method. The associated pointer (NSArray *) holds the reference to the array until the method is left.

Card *card in is a temporary index pointer which holds the reference to one (initialized) item of the array per iteration

Answer 3

The instances do exist; these are just the local names that you're using for them. You're right that nothing would happen if they hadn't been created first, but it's not this method's job to create them.

There is no compiler warning because you've done nothing wrong at compile time: you've taken an object of type NSArray and iterated through it (using the for( ... in theArray ) syntax), with a temporary name for each of its members. It's possible for that array to not exist (be nil ) at runtime, but there's no way for the ObjC compiler to know that; and even if it happened, the result would simply be nothing, not an error.

Later code using this method will look something like this:

Card * aCard = [[Card alloc] init];
// set aCard's properties
NSArray * cards = @[anotherCard, aThirdCard, stillAnotherCard];
[card match:cards];

Where all these objects are created and then passed in to the method as needed.