问题的引入

初始化一个 OC 类，具有如下属性：

1. #import <Foundation/Foundation.h> 

2. NS_ASSUME_NONNULL_BEGIN 

3. @interface LGTeacher : NSObject 

4. @property (nonatomic, copy) NSString *name; 

5. @property (nonatomic, assign) int age; 

6. @property (nonatomic, assign) long height; 

7. @property (nonatomic, strong) NSString *hobby; 

8. @end 

9. NS_ASSUME_NONNULL_END 

初始化对象，并获取对象的内存 size：

1. LGTeacher  *p = [[LGTeacher alloc] init]; 

2. p.name = @"LG_Cooci"; 

3. p.age  = 18; 

4. p.height = 185; 

5. p.hobby  = @"女"; 

6. NSLog(@"%lu - %lu",class_getInstanceSize([p class]),malloc_size((__bridge const void *)(p))); 

打印结果：

由以上打印结果可以看出 class_getInstanceSize 和 malloc_size 获取到的内存大小不一样，那么是什么导致的两者获取同一对象的内存大小不一样呢?我们下一步继续探索。

首先我们先手动计算一下这个对象所占的内存：

• isa -- 8字节

• name -- 8字节

• age -- 4字节

• height -- 8字节

• hobby -- 8字节

• 总计 36 字节。

我们跟踪 objc 源码可以发现改变 size 的地方有两个地方：

• instanceSize 继续跟踪

1.instanceSize

1. size_t instanceSize(size_t extraBytes) const { 

2.         if (fastpath(cache.hasFastInstanceSize(extraBytes))) { 

3.             return cache.fastInstanceSize(extraBytes); 

4.         } 

5.         size_t size = alignedInstanceSize() + extraBytes;// alignedInstanceSize 

6.         // CF requires all objects be at least 16 bytes. 

7.         if (size < 16) size = 16; 

8.         return size; 

9. } 

10. uint32_t alignedInstanceSize() const { 

11.         return word_align(unalignedInstanceSize()); 

12. } 

13. #   define WORD_MASK 7UL 

14. static inline uint32_t word_align(uint32_t x) { 

15.     return (x + WORD_MASK) & ~WORD_MASK; 

16. } 

由以上源码可以得到 instanceSize 使用 8 字节对齐原则处理 Size，并且最小为 16 字节。

2.calloc

由于 calloc 属于 malloc 源码里面

跟踪 libmalloc 源码：

calloc 源码实现：

1. void * 

2. calloc(size_t num_items, size_t size) 

3. { 

4.    void *retval; 

5.    retval = malloc_zone_calloc(default_zone, num_items, size); 

6.     if (retval == NULL) { 

7.         errno = ENOMEM; 

8.     } 

9.     return retval; 

10. } 

11. // malloc_zone_calloc 

13. void * 

14.     malloc_zone_calloc(malloc_zone_t *zone, size_t num_items, size_t size) 

15. { 

16.     MALLOC_TRACE(TRACE_calloc | DBG_FUNC_START, (uintptr_t)zone, num_items, size, 0); 

17.     void *ptr; 

18.     if (malloc_check_start && (malloc_check_counter++ >= malloc_check_start)) { 

19.         internal_check(); 

20.    } 

21.     ptr = zone->calloc(zone, num_items, size); 

22.     if (malloc_logger) { 

23.         malloc_logger(MALLOC_LOG_TYPE_ALLOCATE | MALLOC_LOG_TYPE_HAS_ZONE | MALLOC_LOG_TYPE_CLEARED, (uintptr_t)zone, 

24.                (uintptr_t)(num_items * size), 0, (uintptr_t)ptr, 0); 

25.     } 

26.     MALLOC_TRACE(TRACE_calloc | DBG_FUNC_END, (uintptr_t)zone, num_items, size, (uintptr_t)ptr); 

27.     return ptr; 

28. } 

断点打印 zone->calloc

• ①:得到其真实调用为 default_zone_calloc

• ②：搜索 default_zone_calloc 继续跟进，打印 default_zone_calloc 内部的 zone->calloc 得到 nano_calloc

• ③：分析 nano_calloc 源码可以知道在 _nano_malloc_check_clear 内进行了相关操作

1. static void * 

2. default_zone_calloc(malloc_zone_t *zone, size_t num_items, size_t size) 

3. { 

4.     zone = runtime_default_zone(); 

5.     return zone->calloc(zone, num_items, size); 

6. } 

7. static void * 

9. nano_calloc(nanozone_t *nanozone, size_t num_items, size_t size) 

10. { 

11.     size_t total_bytes; 

12.     if (calloc_get_size(num_items, size, 0, &total_bytes)) { 

13.         return NULL; 

14.     } 

15.     if (total_bytes <= NANO_MAX_SIZE) { 

16.         void *p = _nano_malloc_check_clear(nanozone, total_bytes, 1); 

17.         if (p) { 

18.            return p; 

19.         } else { 

20.             /* FALLTHROUGH to helper zone */ 

21.         } 

22.     } 

23.     malloc_zone_t *zone = (malloc_zone_t *)(nanozone->helper_zone); 

24.     return zone->calloc(zone, 1, total_bytes); 

25. } 

跳转到 _nano_malloc_check_clear 内部发现代码很多，一脸懵逼，但是仔细一看很多都是做一些容错判断，除去这些代码后，返现与size 有关的只有一行代码：

1. size_t slot_bytes = segregated_size_to_fit(nanozone, size, &slot_key); 

跳转进 segregated_size_to_fit 可以看到又是内存对齐的代码，这里的内存对齐是以16字节原则进行对齐的。

1. #define SHIFT_NANO_QUANTUM      4 

2. #define NANO_REGIME_QUANTA_SIZE (1 << SHIFT_NANO_QUANTUM)   // 16 

3. static MALLOC_INLINE size_t 

4. segregated_size_to_fit(nanozone_t *nanozone, size_t size, size_t *pKey) 

5. { 

6.     size_t k, slot_bytes; 

7.     if (0 == size) { 

8.        size = NANO_REGIME_QUANTA_SIZE; // Historical behavior 

9.     } 

10.     k = (size + NANO_REGIME_QUANTA_SIZE - 1) >> SHIFT_NANO_QUANTUM; // round up and shift for number of quanta 

11.     slot_bytes = k << SHIFT_NANO_QUANTUM;                           // multiply by power of two quanta size 

12.     *pKey = k - 1;                                                  // Zero-based! 

13.     return slot_bytes; 

14. } 

总结

经过上述的各种分析，我们可以得到的结论是 instanceSize 是以 8 字节进行对齐的， 后面 calloc 是以 16 字节进行对齐的，说明 calloc 进一步对对象进行了处理。也就解释了我们打印出来的 40-48 了。

由以上可以知道对象申请的内存大小和系统开辟的大小存在不一致的情况，8 字节对齐应用于对象的属性，16 字节对齐应用于对象，由于对象的内存是连续的，这样可以规避一些不必要的风险，以空间换时间来得到更高的安全性。