Question

If I do:

foos[i] = [[Foo alloc] init];
foos[i].prop = @"bar";
[foos[i] baz];

… Is that less efficient than:

Foo *foo = [[Foo alloc] init];
foo.prop = @"bar";
[foo baz];
foos[i] = foo;

or are they equivalent?

Answer 1

If your array is a simple a C array (Foo * array[11];), then it will not have significant performance impact.

If your array is an NSMutableArray (or another subscriptable NS-type), then it will have to call the method’s implementation repeatedly (which uses short circuited dispatch), so that will introduce some overhead. Although some would consider it a micro-optimization. In this case, the compiler cannot know what the implementation returns, so it cannot omit the calls.

---

Here are basic wall clock time results:

MRC:

NSArray: 27 seconds

C Array: 18 seconds

ARC:

NSArray: 31 seconds

C Array: 18 seconds

and the program (which you can perform the obvious ARC changes to to test ARC):

const int NIter = 10000;

__attribute__((noinline)) void fn1() {
  @autoreleasepool {
    NSMutableArray * foos = [NSMutableArray array];
    for (size_t idx = 0; idx < NIter; ++idx) {
      NSMutableString * str = [NSMutableString new];
      foos[0] = str;
      [foos[0] length];
      [foos removeAllObjects];
      [str release];
    }
  }
}

__attribute__((noinline)) void fn2() {
  @autoreleasepool {
    NSMutableString * foos[1];
    for (size_t idx = 0; idx < NIter; ++idx) {
      foos[0] = [NSMutableString new];
      [foos[0] length];
      [foos[0] release];
      foos[0] = 0;
    }
  }
}

int main() {
  for (size_t idx = 0; idx < NIter; ++idx) {
    if (UseNSArray) {
      fn1();
    }
    else {
      fn2();
    }
  }
  return 0;
}