Question

除了给老派Objective-C程序员心脏病发作外，还有其他任何表现影响：

NSMutableArray *derp = @[].mutableCopy

对此：

NSMutableArray *derp = [[NSMutableArray alloc] init];

Answer 1

我将给出与下面不同的答案。

除非你已经衡量了应用程序的性能并发现它缺乏，并且发现它在代码的这一部分中缺乏正确性，否则你会对错误的东西进行优化。（如果你已经这样做了，你可以很容易地测量哪一个更快。）

您应该优化代码的清晰度，编写代码的速度以及正确的可能性。

在这方面，我赞成第一个代码片段。它几乎说明了你要做的事情。第一个片段不仅难以阅读;它还提交了使用点表示法来调用方法的样式错误，而不是获取属性的值。

加上导致心脏病发作并不好。：）

Answer 2

类集群不有额外的分配，它与编译魔术无关。 ~~所以是的，你的例子之间存在显着差异~~（顺便说一下，点符号滥用的互联网点数为-1000。）~~你的第一个例子有两个分配，第二个只有一个。~~

由于我们无法访问NSArray的实际源代码，因此我们可以查看GNUStep（一个开源实现）来了解它们如何处理它。在NSArray.m中（简化和省略不相关的东西）：

static GSPlaceholderArray   *defaultPlaceholderArray;
+ (void) initialize
{
    defaultPlaceholderArray = (GSPlaceholderArray*)
        NSAllocateObject(GSPlaceholderArrayClass, 0, NSDefaultMallocZone());
}

+ (id) alloc
{
    return defaultPlaceholderArray;
}

这里发生的是NSArray定义了一个单独的占位符对象，它总是在alloc中返回。当在这个单例上调用init时，它会实例化正确的私有子类并返回它。

那么，我们如何判断Apple的基金会是否在做同样的事情？很简单，我们只是运行这个测试：

NSArray *a1 = [NSArray alloc];
NSArray *a2 = [NSArray alloc];
NSLog(@"%p, %p", a1, a2);

> "0x100102f30, 0x100102f30"

a1和a2确实具有相同的内存位置，这意味着Apple也可能使用单例方法。如果我们打印出类名__NSPlaceholderArray，那么几乎可以确认它。

所以是的，坚持[NSMutableArray new]：）

更新：Greg Parker指出@[]也是一个单身，因此@[].mutableCopy只会产生一次分配。因此，性能方面的两个例子是相同的。

Answer 3

很难确切地知道创建了多少个对象，尤其是在数组文字的情况下。

The official docs of clang说@[]扩展为arrayWithObjects:count:，我怀疑这是[[[self alloc] initWithObjects:objects count:count] autorelease]。

因此，此时可能会分配第二个对象，因为NSArray是class cluster，而- [NSArray init]的实现可能如下所示：

- (id)init
{
    [self release];
    self = [[__NSArrayI alloc] init];
    return self;
}

为了证实我的怀疑，我写了一个小程序，在不同的阶段打印各类NSArray对象的类。 请注意，为了确定，有必要捕获NSArray的所有分配和初始化方法。在我们这样做之前，我们只能推测。但无论如何，这是代码：

#import <Foundation/Foundation.h>


int main()
{
    NSArray *a = [NSArray alloc];
    NSLog(@"NSArray before init: %@", a.class);

    a = [a init];
    NSLog(@"NSArray after init: %@", a.class);

    NSArray *al = @[];
    NSLog(@"Array literal: %@", al.class);

    NSMutableArray *ma1 = [a mutableCopy];
    NSLog(@"NSMutableArray (copied): %@", ma1.class);

    NSMutableArray *ma2 = [NSMutableArray alloc];
    NSLog(@"NSMutableArray (manufactured) before init: %@", ma2.class);

    ma2 = [ma2 init];
    NSLog(@"NSMutableArray (manufactured) after init: %@", ma2.class);

    return 0;
}

这是打印的内容（为了清晰起见，NSLog()杂乱删除了）：

h2co3-macbook:~ h2co3$ ./quirk
NSArray before init: __NSPlaceholderArray
NSArray after init: __NSArrayI
Array literal: __NSArrayI
NSMutableArray (copied): __NSArrayM
NSMutableArray (manufactured) before init: __NSPlaceholderArray
NSMutableArray (manufactured) after init: __NSArrayM

编辑：这里有一些涉及挂钩的代码。结果非常有趣但是这会打印很多文本，因此鼓励您编译并运行它。基本上，初始化者不直接通过[NSArray init]：

#import <Foundation/Foundation.h>
#import <objc/runtime.h>
#import <objc/message.h>

void hook(Class cls, SEL sel, IMP newimp, IMP *old)
{
    Method m = class_getInstanceMethod(cls, sel);
    *old = method_setImplementation(m, newimp);
}

#define CLS(c) objc_getClass(#c)
#define META(c) objc_getMetaClass(#c)

IMP old_$_NSArray_$_alloc;
IMP old_$_NSMutableArray_$_alloc;
IMP old_$_NSPlaceholderArray_$_alloc;
IMP old_$_NSArrayI_$_alloc;
IMP old_$_NSArrayM_$_alloc;

IMP old_$_NSArray_$_init;
IMP old_$_NSMutableArray_$_init;
IMP old_$_NSPlaceholderArray_$_init;
IMP old_$_NSArrayI_$_init;
IMP old_$_NSArrayM_$_init;

id new_$_NSArray_$_alloc(id self, SEL _cmd)
{
    printf("+ [NSArray<%p> alloc]\n", self);
    return old_$_NSArray_$_alloc(self, _cmd);
}

id new_$_NSMutableArray_$_alloc(id self, SEL _cmd)
{
    printf("+ [NSMutableArray<%p> alloc]\n", self);
    return old_$_NSMutableArray_$_alloc(self, _cmd);
}

id new_$_NSPlaceholderArray_$_alloc(id self, SEL _cmd)
{
    printf("+ [NSPlaceholderArray<%p> alloc]\n", self);
    return old_$_NSPlaceholderArray_$_alloc(self, _cmd);
}

id new_$_NSArrayI_$_alloc(id self, SEL _cmd)
{
    printf("+ [NSArrayI<%p> alloc]\n", self);
    return old_$_NSArrayI_$_alloc(self, _cmd);
}

id new_$_NSArrayM_$_alloc(id self, SEL _cmd)
{
    printf("+ [NSArrayM<%p> alloc]\n", self);
    return old_$_NSArrayM_$_alloc(self, _cmd);
}

id new_$_NSArray_$_init(id self, SEL _cmd)
{
    printf("- [NSArray<%p> init]\n", self);
    return old_$_NSArray_$_init(self, _cmd);
}

id new_$_NSMutableArray_$_init(id self, SEL _cmd)
{
    printf("- [NSMutableArray<%p> init]\n", self);
    return old_$_NSMutableArray_$_init(self, _cmd);
}

id new_$_NSPlaceholderArray_$_init(id self, SEL _cmd)
{
    printf("- [NSPlaceholderArray<%p> init]\n", self);
    return old_$_NSPlaceholderArray_$_init(self, _cmd);
}

id new_$_NSArrayI_$_init(id self, SEL _cmd)
{
    printf("- [NSArrayI<%p> init]\n", self);
    return old_$_NSArrayI_$_init(self, _cmd);
}

id new_$_NSArrayM_$_init(id self, SEL _cmd)
{
    printf("- [NSArrayM<%p> init]\n", self);
    return old_$_NSArrayM_$_init(self, _cmd);
}

int main()
{
    hook(META(NSArray), @selector(alloc), (IMP)new_$_NSArray_$_alloc, &old_$_NSArray_$_alloc);
    hook(META(NSMutableArray), @selector(alloc), (IMP)new_$_NSMutableArray_$_alloc, &old_$_NSMutableArray_$_alloc);
    hook(META(__NSPlaceholderArray), @selector(alloc), (IMP)new_$_NSPlaceholderArray_$_alloc, &old_$_NSPlaceholderArray_$_alloc);
    hook(META(__NSArrayI), @selector(alloc), (IMP)new_$_NSArrayI_$_alloc, &old_$_NSArrayI_$_alloc);
    hook(META(__NSArrayM), @selector(alloc), (IMP)new_$_NSArrayM_$_alloc, &old_$_NSArrayM_$_alloc);

    hook(CLS(NSArray), @selector(init), (IMP)new_$_NSArray_$_init, &old_$_NSArray_$_init);
    hook(CLS(NSMutableArray), @selector(init), (IMP)new_$_NSMutableArray_$_init, &old_$_NSMutableArray_$_init);
    hook(CLS(NSPlaceholderArray), @selector(init), (IMP)new_$_NSPlaceholderArray_$_init, &old_$_NSPlaceholderArray_$_init);
    hook(CLS(NSArrayI), @selector(init), (IMP)new_$_NSArrayI_$_init, &old_$_NSArrayI_$_init);
    hook(CLS(NSArrayM), @selector(init), (IMP)new_$_NSArrayM_$_init, &old_$_NSArrayM_$_init);


    NSArray *a = [NSArray alloc];
    NSLog(@"NSArray before init: %@<%p>", a.class, a);

    a = [a init];
    NSLog(@"NSArray after init: %@<%p>", a.class, a);

    NSArray *al = @[];
    NSLog(@"Array literal: %@<%p>", al.class, al);

    NSMutableArray *ma1 = [a mutableCopy];
    NSLog(@"NSMutableArray (copied): %@<%p>", ma1.class, ma1);

    NSMutableArray *ma2 = [NSMutableArray alloc];
    NSLog(@"NSMutableArray (manufactured) before init: %@<%p>", ma2.class, ma2);

    ma2 = [ma2 init];
    NSLog(@"NSMutableArray (manufactured) after init: %@<%p>", ma2.class, ma2);

    return 0;
}

Answer 4

是的，一个是分配2个对象，另一个不是。我做[NSMutableArray new]

更新：Greg Parker是对的，两者都只分配一个对象。

滥用Objective-C速记表示法

4 个答案: