NSMutableArray memory leaks in recursive method

I have a recursive method that allocates an NSMutableArray, runs a recursive call and then releases the NSMutableArray. the method takes an array of numbers and a target value and then finds what combinations of the numbers can sum up to equal the target value e.g. target: 10, numbers: 5,5,4. the method returns an array of NSNumbers 5 and 5.

My problem is that a mutable array is always showing as a leak in the leaks instrument even though i am releasing it.

here is the recursive method:

-(NSMutableArray *) getCombsHelper:(NSArray *)numbers target:(int)target partial:(NSMutableArray *)partial {

    int s = 0;
    for (NSNumber *number in partial) {
        s += [number intValue];
    }

    if (s == target)  
        [results addObject:partial];


    if (s >= target) 
        return results;


    for (int i = 0; i < [numbe开发者_开发百科rs count]; i++) {

        NSMutableArray *remaining = [[[NSMutableArray alloc] init] autorelease];
        int n = [[numbers objectAtIndex:i] intValue];
        for (int j = i+1; j<[numbers count]; j++) {
            [remaining addObject:[numbers objectAtIndex:j]];
        }

        //this is the array that is showing up as a leak.
        NSMutableArray *partialRec = [[NSMutableArray alloc] initWithArray:partial]; 

        [partialRec addObject:[NSNumber numberWithInt:n]];

        [self getCombsHelper:remaining target:target partial:partialRec];
        [partialRec release]; //the mutable array is released after the recursive call.
    }

    return results;

}

even if i autorelease it i am still getting it as a leak. Could this be a false positive leak? or is there something wrong i cant catch?

That method is odd;

• results appears to be an instance variable that accumulate the results? That is generally odd; typically, you'll have something that calculates state into an ivar and a plain accessor that retrieves the ivar.

To expand: your recursive method is relatively expensive compared to a straight getter method. Say you need results in three places; if this recursive method is the only way to retrieve results, every call will incur calculation overhead. If, instead, you had something like:

- (void)combsHelper:...

- (NSArray*) results
{
    return results;
}

Then you could do the calculation once and retrieve the results many times without incurring overhead (while you could do something like if (!results) [self combsHelper:...] in your getter, that'll lead to the getter causing mutation of state which is generally to be avoided -- best to separate the two).

• don't name methods getSomething:...; get as a prefix is limited to a very specific use pattern (generally, pass by reference retrieval of a value -- uncommon)..

What array is leaking? Keep in mind that Instruments shows you the point of allocation of the leak, not where the real leak happens. If something is retaining the object elsewhere without a balanced release, that'll be your leak.

The leak is outside of this method; partialRec is being added to the results array. Something is probably retrieving it from said array, retaining it, and not balancing that with a release

Perhaps the complaint is that you pass partialRec to the method, then add it to an array (results), which you return, but you don't catch your return value.

Adding it to the array will retain it.

Where does 'results' come from anyway? I don't see its declaration.

You probably have a problem on this line:

[self getCombsHelper:remaining target:target partial:partialRec];

You are passing partialRec to another method, and it is not autoreleased.