Tell me more ×
Stack Overflow is a question and answer site for professional and enthusiast programmers. It's 100% free, no registration required.
up vote 1 down vote favorite

lately I work much with arrays and I'm wonder.. what's diffrences between those two lines.

NSArray *array = [NSArray arrayWithArray:someArray];

and

NSArray *array = [someArray copy];

Which of it is faster? What in case we have NSMutableArray and mutableCopy?

share|improve this question

5 Answers

up vote 6 down vote accepted

Which of it is faster?

Don't worry about it. Premature optimization.

The main difference: the first approach results in an autoreleased "copy" that you don't own and don't have to release, while you do own the object created on the second line. Both arrays will be immutable, by the way.

share|improve this answer
up vote 0 down vote

One of them is probably faster. Run them a million times and see if anyone wins.

In case of NSArray vs NSMutableArray, an immutable array being copied does not have to actually return a copy since it can't change. However, if you have a mutable array, it would need to be copied since you could change the original. And of course doing a mutable copy always needs to return a new object.

In your entire app, the speed and memory difference is probably not going to matter compared to everything else that's going on.

share|improve this answer
up vote 1 down vote

The difference between the two is that the latter will be retained. The former will be autoreleased.

Both versions make a shallow copy of the array.

NSMutableArray *notMutableReally = [NSArray arrayWithArray:aMutableArray];

Should give you a compiler warning as you will be trying to assign a NSArray to a NSMutableArray.

Use.

NSMutableArray *mutableArrayCopy = [NSMutableArray arrayWithArray:aMutableArray];

Which is faster? Dont worry, they are all far faster than the rest of the stuff you will be doing. Check with Instruments if you really care.

share|improve this answer
up vote 1 down vote

The main difference is that -copy knows better how to copy itself (can do it more efficiently and maybe use a more adapted subclass of NSArray) while +arrayWithArray: will create a new instance of NSArray (well, in fact the concrete class used by Foundation for arrays) and feed it with the same list of objects from the initial object. Also it will add an extra autorelease.

So -copy is (very very) likely more efficient.

In fact for immutable NSArrays, -copy is just doing -retain, so it does not even bother creating a new instance.

share|improve this answer
@WarrenBurton It should be foo and bar instead of &foo and &bar, and then you would see that they're the same. Of course the addresses of two variables are different, but their values (which are themselves pointers to the same NSArray object) are identical. Learn C properly before criticising those who know more than you do. Also, printing pointers using %ld leads to undefined behavior - the correct format specifier for pointers is %p (and a cast to void * is still required). – H2CO3 Feb 13 at 10:48
up vote 4 down vote

In addition to the other answers, also note, that when someArray is nil, the first line will make array point to an empty array and the second will make it point to nil. This might be an important difference, especially in mutable arrays.

share|improve this answer

Your Answer

 
discard

By posting your answer, you agree to the privacy policy and terms of service.

Not the answer you're looking for? Browse other questions tagged or ask your own question.