OC对象的本质
- 我们平常编写的 Objective-C 代码，底层实现其实都是 C/C++ 代码
- 具体的实现过程，就是 Objective-C ——>C/C++———>汇编语言———>机器语言
-
注意所以Objective-C的面向对象都是基于C/C++的数据结构实现的
Objective-C转换成C/C++代码
创建一个命令行项目
#import <Foundation/Foundation.h>
int main(int argc, const char * argv[]) {
@autoreleasepool {
NSObject *obj = [[NSObject alloc] init];
NSLog(@"Hello, World!");
}
return 0;
}
在项目的目录下运行clang -rewrite-objc main.m -o main.cpp显示如下，生成.cpp文件
命令：clang -rewrite-objc main.m -o main.cpp
clangXcode 内置的 LLVM 编译器-rewrite-objc从写objc代码main.m源文件-o输出-
main.cppcpp="c plus plus" 既是C++但是上面的命令会输出 多平台代码，内存大（9万多行代码），不便于读取，Windows ，MAC,因此一般需要我们指定平台，用于iPhone手机， 例如
xcrun -sdk iphoneos clang -arch arm64 -rewrite-objc main.m -o main-arm64.cpp命令：xcrun -sdk iphoneos clang -arch arm64 -rewrite-objc OC源文件 -o 输出文件与上条命令相比较多了几点：
-
xcrunXcode run -sdk-
iphoneos指定平台 -
-arch架构 模拟器(i386)、32bit(armv7)、5s后都是64bit（arm64）
-
如果需要链接其他框架，使用-framework参数，比如 -framework UIKit
生成的main-arm64.cpp（3万多行代码），虽然比上面那个9万多行少许多，但也看的一脸懵逼啊，全局搜索int main 函数
int main(int argc, const char * argv[]) {
/* @autoreleasepool */ { __AtAutoreleasePool __autoreleasepool;
NSObject *obj=((NSObject *(*)(id, SEL))(void *)objc_msgSend)((id)((NSObject *(*)(id, SEL))(void *)objc_msgSend)((id)objc_getClass("NSObject"), sel_registerName("alloc")), sel_registerName("init"));
NSLog((NSString *)&__NSConstantStringImpl__var_folders_c0_7nm4_r7s4xd0mbs67ljb_b8m0000gn_T_main_1b47c1_mi_0);
}
return 0;
}
然后搜索 NSObject_IMPL 显示下面的结构体，也就是说Objective-C编译后NSObject对象会编译成下面这个结构体
struct NSObject_IMPL {
Class isa; // 64位中占 8个字节
};
既是， NSObject *obj = [[NSObject alloc] init];
一个NSObject 对象在内存中就是上面那个结构体形式
也就是上面说的，C/C++的结构体支撑了Objective-C
在进入Class中可以看到
typedef struct objc_class *Class;
释义：Class是一个指向结构体的指针 指针在32位中占4个字节，在64位中占8个字节
然后，返回main.m文件，进入NSObject中可以看到和上面的NSObject_IMPL的结构
@interface NSObject <NSObject> {
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Wobjc-interface-ivars"
Class isa OBJC_ISA_AVAILABILITY;
#pragma clang diagnostic pop
}
这就是我们编写的OC语言转换成C++后的代码
思考 一个OC对象在内存中是如何布局的？
-
NSObject的底层实现
实现原理
面试题
一个NSobject对象占用多少内存
- 导入
#import <objc/runtime.h>通过class_getInstanceSize可以查看内存 - 但是NSObject对象内部只使用了8个字节的空间（bit64环境下，可以通过class_getInstanceSize函数获得）
- 导入
#import <malloc/malloc.h>通过malloc_size可以查看内存 - 系统分配了16个字节给NSobject对象（通过malloc_size函数获得）
// 获得NSObject实例对象的成员变量所占用的大小 >> 8
NSLog(@"%zd", class_getInstanceSize([NSObject class]));
// 获得obj指针所指向内存的大小 >> 16
NSLog(@"%zd", malloc_size((__bridge const void *)obj));
分析 ：从下图可以看出，内存分配了16个字节，实际使用的使用8个字节存放isa
- 方式一
通过苹果的开源库 https://opensource.apple.com/tarballs/objc4/
通过查看alloc 底层也能发现，size小于16 会自动取值为16
// 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;
}
- 方式二
代码中打断点，打印obj 的内存，然后使用Xcode查看内存
int main(int argc, const char * argv[]) {
@autoreleasepool {
NSObject *obj = [[NSObject alloc] init];
return 0;
}
使用Xcode 的Debug来调试
Debug——>Debug Workflow ——>View Memory
通过打印可以看出前8个字节有值，后8个直接无值
- 方式三
使用LLDB指令
// print / p 打印指针
(lldb) print obj
(NSObject *) $0 = 0x0000000100753df0
(lldb) p obj
(NSObject *) $1 = 0x0000000100753df0
// po 打印对象
(lldb) po obj
<NSObject: 0x100753df0>
// 读取内存 memory read = x
(lldb) memory read 0x100753df0
0x100753df0: 41 d1 a4 99 ff ff 1d 00 00 00 00 00 00 00 00 00 A...............
0x100753e00: d0 3e 75 00 01 00 00 00 10 41 75 00 01 00 00 00 .>u......Au.....
x/3xw 0x100753df0
x memory read = x
3 数量
x格式
w字节数
0x100753df0 内存地址
格式
x是16进制 f是浮点 d是10进制
字节大小
bbyte 1字节 hhalf word 2字节 wword 4字节 ggiant word 8字节
修改内存中的值
memory write 内存地址 数值
memory write 0x100753df0 10
利用一个简单的对象再次探索OC对象的本质
创建一个对象继承自NSObject
@interface Student : NSObject
{
int _no;
int _age;
}
@end
使用上面的命令生成.cpp文件，查看对应的关键源码
struct NSObject_IMPL {
Class isa;
};
struct Student_IMPL {
struct NSObject_IMPL NSObject_IVARS; // 占8个字节 先写父类的实现，然后写自己的属性
int _age;
int _no;
};
// 上面两个代码等价于
struct Student_IMPL {
Class isa; // 8个字节
int _age; // 4个字节
int _no; // 4个字节
};
猜想 上面的Student对象占用多少内存
- 根据内存对齐，结构体的大小必须是最大成员大小的倍数
上面代码转换流程如下
执行下面代码，得知，分配了16个字节空间，使用了16个字节空间
int main(int argc, const char * argv[]) {
@autoreleasepool {
Student *stu = [[Student alloc] init];
// 通过指针，直接访问成员变量
stu->_no = 4;
stu->_age = 5;
NSLog(@"%zd", class_getInstanceSize([Student class]));
NSLog(@"%zd", malloc_size((__bridge const void *)stu));
//强制stu转化为结构体
struct Student_IMPL *stuImpl = (__bridge struct Student_IMPL *)stu;
NSLog(@"no is %d, age is %d", stuImpl->_no, stuImpl->_age);
}
return 0;
}
思考 一个Person对象，一个Student对象占用多少内存空间
// Person
@interface Person : NSObject
{
int _age;
}
// 16 = isa+_age = 8+4 但是根据内存对齐法则：结构体的大小必须是最大成员大小的倍数
@end
// Student
@interface Student : Person
{
int _no;
}
// 16 = isa+_age +_no = 8+4+4 刚好占用16个字节
@end
内存分布图
再次思考 一个Person对象占用了多少内存空间
@interface Person : NSObject
{
int _age;
int _height;
int _no;
}
// 根据底层实现原理 如下：
struct Person_IMPL {
struct NSObject_IMPL NSObject_IVARS; // 8
int _age; // 4
int _height; // 4
int _no; // 4
};
// 计算结构体大小，内存对齐，应该为结构体中最大成员大小的倍数 为 24
// 打印
Person *p = [[Person alloc] init];
NSLog(@"%zd", sizeof(struct Person_IMPL)); // 24
// 因为系统alloc分配内存为16的倍数，为了内存的速度，所以为 32
NSLog(@"%zd %zd",
class_getInstanceSize([Person class]), // 24
malloc_size((__bridge const void *)(p))); // 32
@end
根据苹果开源库，查看得知
开源库 https://opensource.apple.com/tarballs/libmalloc/
2个容易混淆的函数
- 创建一个实例对象，至少需要多少内存？
-
#import <objc/runtime.h>
class_getInstanceSize([NSObject class])
-
#import <objc/runtime.h>
- 创建一个实例对象，实际上分配了多少内存？
-
#import <malloc/malloc.h>
malloc_size((__bridge const void *) obj)
-
#import <malloc/malloc.h>
扩展
可以使用gnu来窥探，内存分配
