熟悉又陌生的alloc、init、new

有些东西你看着懂了，面试的时候傻眼了，紧张、后悔各种情绪扑面而来，熟悉又陌生带来的最终的结果是GG。

思考壹：大家想过我们创建对象的时候为何先要alloc，然后又要init呢？还是说在我们看来这就是个定律，不用管它的证明，只管用即可？

熟悉的身影：

MyJob *job = [MyJob alloc] init ] ;

熟悉又陌生的身影：

MyJob * job = [MyJob alloc] ;
MyJob * jobOne = [job init] ;
MyJob * jobTwo = [job init] ;

猜猜job、jobOne、jobTwo三个对象指针指向的地址是一样的吗？

1.分析一下[MyJob alloc]在底层都发生了什么？

alloc:根据传入的class对象，返回一个该类的实例对象，并在内存中申请分配空间，根据对象的实例变量，属性的类型使用字节对齐的算法来计算所需的内存的大小。

alloc流程

1.1、一个对象需要分配多大的内存呢？又是如何计算的呢？怎么去查看分配内存的大小呢？

@interface MyJob : NSObject
{
    NSString *name;
    int       money;
}
@end

两种方法查看一个对象分配内存的大小：
第一种：验证方法还是instrument

instrument显示的内存大小

第二种：runtime中class_xxx方法

/**
 * Returns the size of instances of a class.
 *
 * @param cls A class object.
 *
 * @return The size in bytes of instances of the class \e cls, or \c 0 if \e cls is \c Nil.
 */
OBJC_EXPORT size_t class_getInstanceSize(Class cls)
     __OSX_AVAILABLE_STARTING(__MAC_10_5, __IPHONE_2_0);

runtime中对instanceSize做了判断（CF requires all objects be at least 16 bytes）：

size_t instanceSize(size_t extraBytes) {
        size_t size = alignedInstanceSize() + extraBytes;
        // CF requires all objects be at least 16 bytes.
        if (size < 16) size = 16;
        return size;
    }

类型大小图

2、init又做了什么呢？为何我们初始化对象的时候总是不由自主的在后面加上init呢？

- (id)init {
   return _objc_rootInit(self);
}

id
_objc_rootInit(id obj)
{
   // In practice, it will be hard to rely on this function.
   // Many classes do not properly chain -init calls.
   return obj;
}

从runtime源码中可以看到NSObject中的init什么都没有做。直接返回初始化后的对象。这样处理的原因也就解释了我们初始化对象的时候为何要重写init方法了或者initxxx自定义扩展方法了。在重写的init方法中，对成员变量进行初始化，以方便后面的调用。

3、new又是怎么回事呢？

这是runtime中alloc调用的方法：

id
_objc_rootAlloc(Class cls)
{
    return callAlloc(cls, false/*checkNil*/, true/*allocWithZone*/);
}

这是runtime中new调用的方法：

+ (id)new {
    return [callAlloc(self, false/*checkNil*/) init];
}

runtime中callAlloc方法的实现：（其中有一个参数是一个可省略的并且带有默认值的参数）所以两者调用的方法就是参数的区别，最后还是走到了 [cls alloc]方法。

static ALWAYS_INLINE id
callAlloc(Class cls, bool checkNil, bool allocWithZone=false)
{
    if (slowpath(checkNil && !cls)) return nil;

#if __OBJC2__
    if (fastpath(!cls->ISA()->hasCustomAWZ())) {
        // No alloc/allocWithZone implementation. Go straight to the allocator.
        // fixme store hasCustomAWZ in the non-meta class and 
        // add it to canAllocFast's summary
        if (fastpath(cls->canAllocFast())) {
            // No ctors, raw isa, etc. Go straight to the metal.
            bool dtor = cls->hasCxxDtor();
            id obj = (id)calloc(1, cls->bits.fastInstanceSize());
            if (slowpath(!obj)) return callBadAllocHandler(cls);
            obj->initInstanceIsa(cls, dtor);
            return obj;
        }
        else {
            // Has ctor or raw isa or something. Use the slower path.
            id obj = class_createInstance(cls, 0);
            if (slowpath(!obj)) return callBadAllocHandler(cls);
            return obj;
        }
    }
#endif

    // No shortcuts available.
    if (allocWithZone) return [cls allocWithZone:nil];
    return [cls alloc];
}

从runtime的源码中可以看出，使用[xxxx alloc ]init] 与[xxx new]进行初始化没有太大的区别都会走 +alloc方法。
但是init可以自定义扩展接口初始化：例如：initxxxx 而new则不能。

                                        ---------