Return multiple objects from a method in Objective-C

Question

I have a method that takes an NSMutableArray as a parameter, and I would like it to return that array, another array that is created in the method, and an int created by the method. I realize this could be done by making an array that had all these objects in it, and returning that, then removing them from the array outside the method, but is there another way to return multiple objects?

Answer 1

The typical ways to pass back multiple values are to:

• Add extra parameters by reference (ex. typically NSErrors are passed this way)
• Pass them back in some other struct or object, typically an NSDictionary or a custom class

The above are good solutions for many situations, but here is another solution that may work best in other situations:

Add a block to your method:

- (void)myMethodWithMultipleReturnObjectsForObject:(id)object returnBlock:(void (^)(id returnObject1, id returnObject2))returnBlock
{
    // do stuff

    returnBlock(returnObject1, returnObject2);
}

Then use the method like this:

[myMethodWithMultipleReturnObjectsForObject:object returnBlock:^(id returnObject1, id returnObject2) {
    // Use the return objects inside the block
}];

The return objects in the above example are only usable within the block, so if you want to keep them around for use outside the block, just set some __block vars.

// Keep the objects around for use outside of the block
__block id object1;
__block id object2;
[myMethodWithMultipleReturnObjectsForObject:object returnBlock:^(id returnObject1, id returnObject2) {
    object1 = returnObject1;
    object2 = returnObject2;
}];

Answer 2

Using an NSDictionary to return multiple values is the customary way to do this in Obj-C.

The method signature would look something like this:

-(NSDictionary *)doSomeStuffThatReturnsMultipleObjects;

and you are going to want to define your dictionary keys in the appropriate files.

// Header File
extern NSString *const JKSourceArray;
extern NSString *const JKResultsArray;
extern NSString *const JKSomeNumber;

// Implementation File
NSString *const JKSourceArray = @"JKSourceArray";
NSString *const JKResultsArray = @"JKResultsArray";
NSString *const JKSomeNumber = @"JKSomeNumber";

The advantage over using an array is that the the order of elements and the presence/absence of elements doesn't matter, making it far easier to extend in the future, if you want to return additional objects. It's also far more flexible and extensible than passing by reference.

Answer 3

Another way you can do it is have the user pass a pointer which they want to use to hold the data. Here is a sample that returns an array and uses pointers to give you an int value and another array. EDIT ok here is the working version I just tested it myself:

- (NSMutableArray*)doStuff:(int*)container returnedArray:(NSMutableArray*)arrayContainer{
   int a = 4;
   *container = a;
   [arrayContainer removeAllObjects];
   [arrayContainer addObject:@"object"];
   return [NSMutableArray arrayWithObjects:@"object",nil];
}

That way you could say like:

int value = 0;
NSMutableArray* new = [NSMutableArray array];
[self doStuff:&value returnedArray:new];

And it basicly works like a return!