本文使用的 runtime 版本为 objc4-706。
+alloc 和 -init 是我们经常使用的两个方法，通常它们也是以 [[SomeClass alloc] init] 这个形式出现的，本篇文章对它们的实现做一点记录。
alloc
在 NSObject.mm 中，可以找到 +alloc 的实现：
+ (id)alloc {
return _objc_rootAlloc(self);
}
+alloc 的实现就是简单的将事情甩给了 _objc_rootAlloc，接着看 _objc_rootAlloc 的实现：
// Base class implementation of +alloc. cls is not nil.
// Calls [cls allocWithZone:nil].
id
_objc_rootAlloc(Class cls)
{
return callAlloc(cls, false/*checkNil*/, true/*allocWithZone*/);
}
_objc_rootAlloc 也是一个甩锅侠，将锅甩给了 callAlloc，继续看 callAlloc 的实现：
// Call [cls alloc] or [cls allocWithZone:nil], with appropriate
// shortcutting optimizations.
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];
}
其中
slowpath和fastpath宏的定义如下：
#define fastpath(x) (__builtin_expect(bool(x), 1))
#define slowpath(x) (__builtin_expect(bool(x), 0))
__builtin_expect起的是优化性能的作用，表示分支预测时第一个参数较大概率会是第二个参数，所以fastpath（x)表示x较大概率为真，slowpath(x)表示x较大概率为假，返回值就是x本身。
回到 callAlloc，刚开始的一句 if (slowpath(checkNil && !cls)) return nil; 进行了对 cls 参数为 nil 的判断，使用的是 slowpath，表示这是比较不可能出现的情况。
接下来从 #if __OBJC2__ 开始至 #endif，都是在 Objective-C 2.0 下才会有的代码，那当然是我们需要关注的地方了，毕竟我们现在使用的就是 Objective-C 2.0。
其中，首先要进行一下判断：if (fastpath(!cls->ISA()->hasCustomAWZ())) { ... }，这里判断一个类是否有自定义的 +allocWithZone: 实现，有的话，就不能走这里面的默认实现了。
继续关注默认实现，接下来进行判断 if (fastpath(cls->canAllocFast())) { ... } else { ... }。首先关于 canAllocFast 的定义是这样的，在 objc-runtime-new.h 中：
#if FAST_ALLOC
...
bool canAllocFast() {
return bits & FAST_ALLOC;
}
#else
size_t fastInstanceSize() {
abort();
}
void setFastInstanceSize(size_t) {
// nothing
}
bool canAllocFast() {
return false;
}
#endif
同样还是在 objc-runtime-new.h 中，可以看到有关 FAST_ALLOC 的定义：
#if !__LP64__
...
#elif 1
// Leaks-compatible version that steals low bits only.
... 根本没有 FAST_ALLOC ...
#else
// Leaks-incompatible version that steals lots of bits.
...
// summary bit for fast alloc path: !hasCxxCtor and
// !instancesRequireRawIsa and instanceSize fits into shiftedSize
#define FAST_ALLOC (1UL<<50)
// instance size in units of 16 bytes
// or 0 if the instance size is too big in this field
// This field must be LAST
#define FAST_SHIFTED_SIZE_SHIFT 51
// FAST_ALLOC means
// FAST_HAS_CXX_CTOR is set
// FAST_REQUIRES_RAW_ISA is not set
// FAST_SHIFTED_SIZE is not zero
// FAST_ALLOC does NOT check FAST_HAS_DEFAULT_AWZ because that
// bit is stored on the metaclass.
#define FAST_ALLOC_MASK (FAST_HAS_CXX_CTOR | FAST_REQUIRES_RAW_ISA)
#define FAST_ALLOC_VALUE (0)
#endif
其中的 #elif 1 真是亮瞎狗眼。所以现在使用的 runtime 里根本就没有 FAST_ALLOC 这个玩意……所以现在 canAllocFast 其实是一个永远返回 false 的函数了，那我们只需要关心上面判断中 else 里的代码了。
else 里只有 3 行代码：
id obj = class_createInstance(cls, 0);if (slowpath(!obj)) return callBadAllocHanlder(cls);return obj;
很明显，1 就是创建对象的调用，2 用来进行错误处理。对于我们现在所关心的，那就是 class_createInstance 函数了。在 objc-runtime-new.mm，可以找到它的实现：
id
class_createInstance(Class cls, size_t extraBytes)
{
return _class_createInstanceFromZone(cls, extraBytes, nil);
}
可以看到它只是调用了 _class_createInstanceFromZone，其第三个参数是 zone，用来表示 NSZone，但是 NSZone 已经是个没有使用的东西，所以这里直接传入了 nil。
还是在 objc-runtime-new.mm 中，可以看到 _class_createInstanceFromZone 的实现：
static __attribute__((always_inline))
id
_class_createInstanceFromZone(Class cls, size_t extraBytes, void *zone,
bool cxxConstruct = true,
size_t *outAllocatedSize = nil)
{
if (!cls) return nil;
assert(cls->isRealized());
// Read class's info bits all at once for performance
bool hasCxxCtor = cls->hasCxxCtor();
bool hasCxxDtor = cls->hasCxxDtor();
bool fast = cls->canAllocNonpointer();
size_t size = cls->instanceSize(extraBytes);
if (outAllocatedSize) *outAllocatedSize = size;
id obj;
if (!zone && fast) {
obj = (id)calloc(1, size);
if (!obj) return nil;
obj->initInstanceIsa(cls, hasCxxDtor);
}
else {
if (zone) {
obj = (id)malloc_zone_calloc ((malloc_zone_t *)zone, 1, size);
} else {
obj = (id)calloc(1, size);
}
if (!obj) return nil;
// Use raw pointer isa on the assumption that they might be
// doing something weird with the zone or RR.
obj->initIsa(cls);
}
if (cxxConstruct && hasCxxCtor) {
obj = _objc_constructOrFree(obj, cls);
}
return obj;
}
函数一开始会对 cls 判断 nil，如果 cls 是 nil 的话就直接返回 nil，这算是遵循着 Objective-C 中对 nil 发送消息不会崩溃的一致性吧。
接下来的 assert(cls->isRealized());，断言 cls 是已经 realize 了，关于类的 realize 是什么，可以看一下「Objective-C 小记（5）类的加载」，其中有简略的介绍。
接下来的 hasCxxCtor 和 hasCxxDtor 是对 Objective-C++ 的支持，表示这个类是否有 C++ 类构造函数和析构函数，如果有的话，需要进行额外的工作。而 fast，是对 isa 的类型的区分，如果一个类的实例不能使用 isa_t 类型的 isa 的话，fast 就为 false，但是在 Objective-C 2.0 中，大部分类都是支持的。关于 isa 的类型，可以看看「Objective-C 小记（1）Messaging」和「Objective-C 小记（2）对象 2.0」。
接着要获得 size，想要创建一个对象当然要知道它有多大，才能给它分配合适大小的内存，size 是通过 cls->instanceSize(extraBytes) 来获得的，可以看一下 instanceSize 的实现：
// May be unaligned depending on class's ivars.
uint32_t unalignedInstanceSize() {
assert(isRealized());
return data()->ro->instanceSize;
}
// Class's ivar size rounded up to a pointer-size boundary.
uint32_t alignedInstanceSize() {
return word_align(unalignedInstanceSize());
}
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;
}
不难看出就是从 cls 的 ro 中获得 instanceSize 然后将它对齐，并加上 extraBytes，最后 Core Foundation 需要对象至少要有 16 字节，小于 16 的统统返回 16。
在进行了 id obj; 的声明后，就要真正的创建 obj 这个对象了，首先对 zone 和 fast 进行判断，如果没有 zone 并且 fast 为真，这是现在最常见的情况了，因为 zone 肯定是没有的，NSZone 已经弃用了，fast 几乎也都是真，在这个分支里面，obj 首先使用大家都熟悉的 C 标准库这套内存申请函数中的 calloc 申请了一个 size 大小的空间，然后使用 initInstanceIsa 进行初始化。对于下面的分支，zone 也肯定还是没有的，所以还是会调用 obj = (id)calloc(1, size); 申请空间，之后会调用 initIsa：
inline void
objc_object::initIsa(Class cls)
{
initIsa(cls, false, false);
}
initIsa 只是调用了另一个 initIsa，这个 initIsa 会在后面讲到。
继续关注最常见的 initInstanceIsa 的调用，它的实现可以在 objc-object.h 中看到：
inline void
objc_object::initInstanceIsa(Class cls, bool hasCxxDtor)
{
assert(!cls->instancesRequireRawIsa());
assert(hasCxxDtor == cls->hasCxxDtor());
initIsa(cls, true, hasCxxDtor);
}
在进行了两个断言后，同样将任务交给了 initIsa：
inline void
objc_object::initIsa(Class cls, bool nonpointer, bool hasCxxDtor)
{
assert(!isTaggedPointer());
if (!nonpointer) {
isa.cls = cls;
} else {
assert(!DisableNonpointerIsa);
assert(!cls->instancesRequireRawIsa());
isa_t newisa(0);
#if SUPPORT_INDEXED_ISA
assert(cls->classArrayIndex() > 0);
newisa.bits = ISA_INDEX_MAGIC_VALUE;
// isa.magic is part of ISA_MAGIC_VALUE
// isa.nonpointer is part of ISA_MAGIC_VALUE
newisa.has_cxx_dtor = hasCxxDtor;
newisa.indexcls = (uintptr_t)cls->classArrayIndex();
#else
newisa.bits = ISA_MAGIC_VALUE;
// isa.magic is part of ISA_MAGIC_VALUE
// isa.nonpointer is part of ISA_MAGIC_VALUE
newisa.has_cxx_dtor = hasCxxDtor;
newisa.shiftcls = (uintptr_t)cls >> 3;
#endif
// This write must be performed in a single store in some cases
// (for example when realizing a class because other threads
// may simultaneously try to use the class).
// fixme use atomics here to guarantee single-store and to
// guarantee memory order w.r.t. the class index table
// ...but not too atomic because we don't want to hurt instantiation
isa = newisa;
}
}
函数一开始的 assert(!isTaggedPointer()); 是断言对象的指针不是 Tagged Pointer，比如像 NSNumber，它的数值可以直接存在对象指针上，对象指针是一个 Tagged Pointer，但是 NSNumber 是有自己的 +allocWithZone: 的实现的。因此我个人也不清楚这个断言在这的用处大小了，但这不妨碍我们继续看下面的代码。
接下来就是对 isa 类型的判断 if (!nonpointer) { ... } else { ... }，如果 isa 不是 nonpointer，也就是单纯的指针（Class 类型），则 isa 就直接被赋值为 cls。如果 isa 是 nonpointer，也就是 isa_t 类型的话，则先初始化一个所有位为 0 的指针 isa_t newisa(0)。
关于
SUPPORT_INDEXED_ISA宏，它的定义是这样的：
// Define SUPPORT_INDEXED_ISA=1 on platforms that store the class in the isa
// field as an index into a class table.
// Note, keep this in sync with any .s files which also define it.
// Be sure to edit objc-abi.h as well.
#if __ARM_ARCH_7K__ >= 2
# define SUPPORT_INDEXED_ISA 1
#else
# define SUPPORT_INDEXED_ISA 0
#endif
__ARM_ARCH_7K__这个宏的信息在网上完全找不到，但是我们可以发现在 Xcode 中，watchOS 的 valid architectures 是armv7k，所以__ARM_ARCH_7K__应该是在 Apple Watch 上的架构，并且可能它与 Apple Watch 的代数是有关系的（第一代和第二代）。因此SUPPORT_INDEXED_ISA这个所谓的 indexed isa，应该是对 watchOS 的优化（记忆中 Apple 有提及对 watchOS 进行过优化，我猜这也是一项了）。当然，以上都只是我的猜测……
我们现在不关心 SUPPORT_INDEXED_ISA 里的内容，只看 #else 里的：
newisa.bits = ISA_MAGIC_VALUE;
// isa.magic is part of ISA_MAGIC_VALUE
// isa.nonpointer is part of ISA_MAGIC_VALUE
newisa.has_cxx_dtor = hasCxxDtor;
newisa.shiftcls = (uintptr_t)cls >> 3;
可以看到，先将 newisa 的 bits 赋值为常量 ISA_MAGIC_VALUE，里面包括了 magic 和 nonpointer 的值。然后将是否有 C++ 析构函数标示上，最后将位移（shift）后的 cls 存入 shiftcls（类指针按照 8 字节对齐，所以最后三位一定是 0，所以可以右移三位来节省位的使用）。
最后将 isa = newisa，工作就结束了。
至此，+alloc 的实现就告一段落了。
init
在 NSObject.mm 中，可以找到 -init 的实现：
- (id)init {
return _objc_rootInit(self);
}
简单的调用了 _objc_rootInit 函数，在同一个文件中也能找到它的实现：
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;
}
_objc_rootInit 函数直接就将 obj 返回了，所以 -init 方法其实什么都没有做。
但是开发者留下的注释非常值得玩味，说到很多类没有使用 [super init]，所以这个函数非常靠不住（很可能不被调用）。看起来应该是个历史遗留问题，从上面对 +alloc 的分析也能看出，+alloc 把所有的工作都做完了（初始化了 isa，我个人认为理论上初始化 isa 应该是 -init 的工作）。
总结
Objective-C 中创建对象，直白的看就是和 C 是一样的，使用 calloc 申请内存空间，然后对结构体进行初始化，虽然夹杂着很多细节，但本质上就是这样。
