1. 我们平时编写的Objective-C代码，底层实现其实都是C\C++代码
image.png
2. Objective-C 的对象，类主要是基于C\C++的什么数据结构实现的
结构体
3. 如何将Objective-C 代码转为C\C++代码
以 main.m 文件为例
1. 打开终端进入源文件目录
2. xcrun -sdk iphoneos clang -arch arm64 -rewrite-objc main.m -o main.cpp
4. NSObject对象在内存中是如何布局的?
NSObject 对象类是这样的：
@interface NSObject {
Class isa ;
}
可以看到NSObject对象只有一个isa的成员变量
Class 是一个指针,定义为：typedef struct objc_class *Class;
在编译成c++代码的cpp文件里,对于NSObject对象你可以找到对应的一个结构体
struct NSObject_IMPL {
Class isa;
};
显而易见，NSObject对象底层的实现就是结构体，名为NSObject_IMPL的结构体。
5. 一个NSObject对象占用多少内存？
系统分配了16个字节给NSObject对象（通过malloc_size函数获得）
但 NSObject对象内部只使用了8个字节的空间（64bit环境下，可以通过class_getInstanceSize函数获得）
从上面的NSObject对象内存中的布局我们可以知道，NSObject类实际可以看成
@interface NSObject {
objc_class * isa ;
}
我们可以看到NSObject对象里只有一个成员变量isa, isa是一个指针类型，在64位环境下，指针类型占8个字节。
这是否证明NSObject对象就占了8个字节的空间呢？
下面，我们通过两个方法去验证下
// 获取NSObject类实例对象的大小，需#import <objc/runtime.h>
NSLog(@"%zd", class_getInstanceSize([NSObject class]));
// 获取NSObject对象指针所指向内存大小，需#import <malloc/malloc.h>
NSLog(@"%zd", malloc_size((__bridge const void *)[[NSObject alloc] init]));
打印结果让人意外
2021-01-12 22:36:14.328718+0800 Project[3092:64460] 8
2021-01-12 22:36:14.329021+0800 Project[3092:64460] 16
究竟哪个是对的？ 为什么class_getInstanceSize和malloc_size的结果不一样？
我们通过它们的源码一探究竟。
apple源码 点击这里获取objc 最新的源码，我当前用的版本是 objc4-818.2.tar.gz
打开源码
搜索class_getInstanceSize，我们可以在objc-class.mm 中找到实现：
size_t class_getInstanceSize(Class cls)
{
if (!cls) return 0;
return cls->alignedInstanceSize();
}
点开alignedInstanceSize方法，我们可以看到：
// Class's ivar size rounded up to a pointer-size boundary.
uint32_t alignedInstanceSize() const {
return word_align(unalignedInstanceSize());
}
所以我们可以知道class_getInstanceSize方法的作用就是 “Class's ivar size rounded up to a pointer-size boundary.”
翻译下就是以指针大小为边界，获取类的成员变量大小。
搜索alloc ，我们可以在NSObject.mm中找到实现
+ (id)alloc {
return _objc_rootAlloc(self);
}
一步步往下找
// 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*/);
}
// Call [cls alloc] or [cls allocWithZone:nil], with appropriate
// shortcutting optimizations.
static ALWAYS_INLINE id
callAlloc(Class cls, bool checkNil, bool allocWithZone=false)
{
#if __OBJC2__
if (slowpath(checkNil && !cls)) return nil;
if (fastpath(!cls->ISA()->hasCustomAWZ())) {
return _objc_rootAllocWithZone(cls, nil);
}
#endif
// No shortcuts available.
if (allocWithZone) {
return ((id(*)(id, SEL, struct _NSZone *))objc_msgSend)(cls, @selector(allocWithZone:), nil);
}
return ((id(*)(id, SEL))objc_msgSend)(cls, @selector(alloc));
}
/***********************************************************************
* class_createInstance
* fixme
* Locking: none
*
* Note: this function has been carefully written so that the fastpath
* takes no branch.
**********************************************************************/
static ALWAYS_INLINE id
_class_createInstanceFromZone(Class cls, size_t extraBytes, void *zone,
int construct_flags = OBJECT_CONSTRUCT_NONE,
bool cxxConstruct = true,
size_t *outAllocatedSize = nil)
{
ASSERT(cls->isRealized());
// Read class's info bits all at once for performance
bool hasCxxCtor = cxxConstruct && cls->hasCxxCtor();
bool hasCxxDtor = cls->hasCxxDtor();
bool fast = cls->canAllocNonpointer();
size_t size;
size = cls->instanceSize(extraBytes);
if (outAllocatedSize) *outAllocatedSize = size;
id obj;
if (zone) {
obj = (id)malloc_zone_calloc((malloc_zone_t *)zone, 1, size);
} else {
obj = (id)calloc(1, size);
}
if (slowpath(!obj)) {
if (construct_flags & OBJECT_CONSTRUCT_CALL_BADALLOC) {
return _objc_callBadAllocHandler(cls);
}
return nil;
}
if (!zone && fast) {
obj->initInstanceIsa(cls, hasCxxDtor);
} else {
// Use raw pointer isa on the assumption that they might be
// doing something weird with the zone or RR.
obj->initIsa(cls);
}
if (fastpath(!hasCxxCtor)) {
return obj;
}
construct_flags |= OBJECT_CONSTRUCT_FREE_ONFAILURE;
return object_cxxConstructFromClass(obj, cls, construct_flags);
}
在上面这个_class_createInstanceFromZone 我们可以看到outAllocatedSize=cls->instanceSize(extraBytes);
继续查instanceSize
我们在objc-runtime-new.m 的源文件中找到这个方法实现
inline size_t instanceSize(size_t extraBytes) const {
if (fastpath(cache.hasFastInstanceSize(extraBytes))) {
return cache.fastInstanceSize(extraBytes);
}
size_t size = alignedInstanceSize() + extraBytes;
// CF requires all objects be at least 16 bytes.
if (size < 16) size = 16;
return size;
}
关键点就在if (size < 16) size = 16;
这表明，NSObject对象在分配内存空间的时候，如果不足16个字节，会自动补足16个字节。
因此上面打印的不同结果也就有了解释，这个问题也就有了解答。
系统为NSObject对象分配了16个字节的内存空间，但是实际上它只用了8个字节，还空着8个字节。
我们可以查看NSObject对象的内存地址去做进一步验证
- 如何实时查看内存
1. Xcode工具栏 - Debug - Debug workflow - View Memory
打开View Memory同时可以看到他的快捷键 ctrl+option+command+shift+M
2. 命令行调试
memory read 内存地址
截屏2021-01-13 下午6.23.50.png
图形化查看与命令行查看
image.png
image.png
我们知道，1个十六进制数位对应着4个二进制数位，8个二进制数位对应着1个字节
所以2个十六进制数位对应着1个字节
所以NSObject对象在内存里只用了前8个字节，后8个字节空着
- 联想下，继承自NSObject的子类对象内存是怎么分配的
对于如下的Person类和Student 类，系统会为他们分配多少内存空间
@interface Person : NSObject {
@public
int _age;
}
@end
@interface Student : Person {
@public
NSString * _name;
}
@end
Person *person = [[Person alloc] init];
Student *student = [[Student alloc]init];
NSLog(@"person: %zd %zd", class_getInstanceSize([Person class]), malloc_size((__bridge const void*)(person)));
NSLog(@"student: %zd %zd", class_getInstanceSize([Student class]), malloc_size((__bridge const void*)(student)));
2021-01-13 23:41:07.757045+0800 Project[6523:274517] person: 16 16
2021-01-13 23:41:07.757440+0800 Project[6523:274517] student: 24 32
****************************************************************************
照葫芦画瓢，把代码转成C++代码后可以找到几个类对应的结构体
struct NSObject_IMPL {
Class isa; // 8个字节
};
struct Person_IMPL {
struct NSObject_IMPL NSObject_IVARS; // 8个字节
int _age; // 4个字节
};
struct Student_IMPL {
struct Person_IMPL Person_IVARS; // 16个字节 空了4个字节
NSString *_name; // 8个字节
};
不难看出，子类对应的结构体的第一个成员是父类的结构体类型，之后跟着自己的成员变量
但是看着控制台打印出来的结果
person：class_getInstanceSize得到的16字节，而我们看到的Person_IMPL成员实际上只占了12个字节。
这涉及到了一个内存对齐的概念。
之前我们看class_getInstanceSize的源码定位到了这一段
// Class's ivar size rounded up to a pointer-size boundary.
uint32_t alignedInstanceSize() const {
return word_align(unalignedInstanceSize());
}
word_align的方法在objc-os.h文件里
# define WORD_MASK 7UL
static inline size_t word_align(size_t x) {
return (x + WORD_MASK) & ~WORD_MASK;
}
下面来解读下这段代码
WORD_MASK 是一个无符号长整型数值 7，它对应的二进制数值是00000111
取反就是11111000
上面的代码也就是 (00000111+x) & 11111000
00000111 + x 运算，对于NSObject对象来讲，x肯定是大于等于8的，即和是大于等于15的 也就是最少是00001111
也就是 00001111 & 11111000 = 00001000 = 8
用类似十进制的竖式或许更直观，
00001111
11111000
-------------
00001000
除了后三位一定是0外，前面任意存在一个1都会是8的倍数
所以可以看到word_align得到的字节数一定是8的倍数, 所以获取到的person成员变量的内存大小为16字节
struct内存对齐的三个原则可以百度一下
对于alloc来讲，之前我们也定位到了_class_createInstanceFromZone方法
摘出关键部分代码：
size_t size;
size = cls->instanceSize(extraBytes);
if (outAllocatedSize) *outAllocatedSize = size;
id obj;
if (zone) {
obj = (id)malloc_zone_calloc((malloc_zone_t *)zone, 1, size);
} else {
obj = (id)calloc(1, size);
}
instanceSize 的实现
inline size_t instanceSize(size_t extraBytes) const {
if (fastpath(cache.hasFastInstanceSize(extraBytes))) {
return cache.fastInstanceSize(extraBytes)
}
size_t size = alignedInstanceSize() + extraBytes;
// CF requires all objects be at least 16 bytes.
if (size < 16) size = 16
return size;
}
// Class's ivar size rounded up to a pointer-size boundary.
uint32_t alignedInstanceSize() const
return word_align(unalignedInstanceSize());
}
也就是说 传入malloc_zone_calloc 或者calloc方法的size实际上就是class_getInstanceSize方法获得的内存大小
所以，你申请size大小的内存，系统并不会耿直地只分给你size大小的内存。
至于其中的原理，我们需要到calloc的实现里面一探究竟。
calloc 方法的具体源码可以在libmalloc库里面查看， 系统是以16个字节为单位进行内存对齐的。
源码需要配置一下，最新版的有个别的文件没有找到所以用的 166.200.60 版本
配置的坑不少，感谢dandelionYD提供的配置流程，有想动手的小伙伴可以参考libmalloc-166.200.60之源码编译
可编译版本的传送门
代码蛮晦涩，详解未完待续
推荐阅读cocci大神的 iOS 高级之美（六）—— malloc分析 很详尽
