NSObject 对象占用内存

NSObject *obj = [[NSObject alloc] init];

分析

xcrun -sdk iphoneos clang -arch arm64 -rewrite-objc main.m -o main-arm64.cpp

/// An opaque type that represents an Objective-C class.
typedef struct objc_class *Class;
struct NSObject_IMPL {
    Class isa;
};

OC的面向对象的能力是通过底层 C\C++ 的结构体支持的,类的本质在 C\C++ 的底层是结构体

基类NSObject内部仅有一个 isa的结构体指针,占8个字节.这个结论是否正确那
系统提供了一个查看对象分配内存大小的函数malloc_size(const void *ptr)
验证获得的结果是16, whywhy

进一步查看alloc 的实现,alloc 本质会调用allocWithZone,删除多余信息获得的源码如下

+ (id)allocWithZone:(struct _NSZone *)zone {
    return _objc_rootAllocWithZone(self, (malloc_zone_t *)zone);
}
id _objc_rootAllocWithZone(Class cls, malloc_zone_t *zone)
{
    id obj;
    obj = class_createInstance(cls, 0);
    return obj;
}
id class_createInstance(Class cls, size_t extraBytes)
{
    return _class_createInstanceFromZone(cls, extraBytes, nil);
}
id _class_createInstanceFromZone(Class cls, size_t extraBytes, void *zone, 
                              bool cxxConstruct = true, 
                              size_t *outAllocatedSize = nil)
{
    size_t size = cls->instanceSize(extraBytes);
    obj = (id)calloc(1, size);
    return obj;
}

size_t instanceSize(size_t extraBytes) {
    size_t size = alignedInstanceSize() + extraBytes;
    if (size < 16) size = 16;
    return size;
}

一步一步获取到底层本质了,Apple 内部原来有个限制最低分配的内存大小是16

一个多层继承关系中的对象内存该如何分析那

@interface A : NSObject{
    int a;}
@end
@implementation A
@end
@interface B : A{
    int b;}
@end
@implementation B
@end

@interface C : B{
    int c;}
@end
@implementation C
@end

首先编译为 C++ 进行本质分析

struct NSObject_IMPL {
    Class isa;
};
struct A_IMPL {
    struct NSObject_IMPL NSObject_IVARS;
    int a;
};
struct B_IMPL {
    struct A_IMPL A_IVARS;
    int b;
};
struct C_IMPL {
    struct B_IMPL B_IVARS;
    int c;
};

A 中有一个结构体,该结构体中只有一个指针,占用8个字节,A 中还有一个成员变量 a, 占用4个字节,所以 A的对象成员占用12个字节,不满16字节,补齐16字节;类似分析可知 A 16字节, B 16 字节, C 20字节

通过 malloc_size 进行验证得到的结果是A 16, B 16, C 32 ,why why
runtime提供了一个方法class_getInstanceSize(Class cls)获得类的对象的所有成员变量的内存占用大小,验证得到A 16, B 16, C 24;

查看class_getInstanceSize()源码

size_t class_getInstanceSize(Class cls)
{
    return cls->alignedInstanceSize();
}

 uint32_t alignedInstanceSize() {
        return word_align(unalignedInstanceSize()); 
}

static inline uint32_t word_align(uint32_t x) {
    return (x + WORD_MASK) & ~WORD_MASK;
}
#define WORD_MASK 7UL

可知word_align()得到对齐后的结构体大小,内部实现可知是按8字节进行对齐的.
分析可以得到 C 即使对齐也应该是返回的24,那么32是如何而来的那.

只能继续查看 alloc 源码

#define NANO_MAX_SIZE           256 /* Buckets sized {16, 32, 48, 64, 80, 96, 112, ...} */
static void *
nano_malloc(nanozone_t *nanozone, size_t size)
{
    if (size <= NANO_MAX_SIZE) {
        void *p = _nano_malloc_check_clear(nanozone, size, 0);
        return *p;
        }
}

_nano_malloc_check_clear(nanozone_t *nanozone, size_t size, boolean_t cleared_requested)
{
    void *ptr;
    size_t slot_bytes = segregated_size_to_fit(nanozone, size, &slot_key); 
    ...
    }
#define NANO_REGIME_QUANTA_SIZE     (1 << SHIFT_NANO_QUANTUM)   // 16
#define SHIFT_NANO_QUANTUM      4
static MALLOC_INLINE size_t
segregated_size_to_fit(nanozone_t *nanozone, size_t size, size_t *pKey)
{
    k = (size + NANO_REGIME_QUANTA_SIZE - 1) >> SHIFT_NANO_QUANTUM; slot_bytes = k << SHIFT_NANO_QUANTUM;
    return slot_bytes;
}

当对象分配的内存在256字节以内时,系统分配的内存大小是按16字节对齐的,这也就证明了字节数是32的由来

补充,关于结构体的内存对齐规则

1. 对于结构的各个成员，第一个成员位于偏移为0的位置，以后每个数据成员的偏移量必须是min(#pragma pack()指定的数，这个数据成员的自身长度) 的倍数。
2. 结构体作为成员:如果一个结构里有某些结构体成员,则结构体成员要从其内部最大元素大小的整数倍地址开始存储.(struct a里存有struct b,b里有char,int ,double等元素,那b应该从8的整数倍开始存储.)
3. 在数据成员完成各自对齐之后，结构(或联合)本身也要进行对齐，对齐将按照#pragma pack指定的数值和结构(或联合)最大数据成员长度中，比较小的那个进行。

所以,相同的成员变量,不同的顺序可以操作分配内存大小不同

转载于:https://my.oschina.net/sshsxl/blog/2068372