[TOC]
xcrun -sdk iphoneos clang -arch arm64 -rewrite-objc main.m -o main-arm64.cpp 生成iOS真機的C++代碼
面試題：一個NSObject對象占用多少內存？
OC如下代碼
#import <Foundation/Foundation.h>
int main(int argc, const char * argv[]) {
@autoreleasepool {
NSObject *objc = [[NSObject alloc] init];
NSLog(@"Hello, World!");
}
return 0;
}
一: Objective-c的本質：
OC的對象結構都是通過基礎C\C++的結構體實現的
我們通過創建OC文件及對象，并將OC文件轉化為C++文件來探尋OC對象的本質
1.1: OC文件轉化為C++代碼
clang轉化(不區分平臺)
我們通過命令行將OC的mian.m文件轉化為c++文件。
clang -rewrite-objc main.m -o main.cpp // 這種方式沒有指定架構例如arm64架構 其中cpp代表（c plus plus）
生成 main.cpp
xcrun轉化(區分平臺 推薦！！)
我們可以指定架構模式的命令行，使用xcode工具 xcrun
xcrun -sdk iphoneos clang -arch arm64 -rewrite-objc main.m -o main-arm64.cpp
生成 main-arm64.cpp
1.2 查看C++源碼
main-arm64.cpp 文件中搜索NSObjcet，可以找到NSObjcet_IMPL（IMPL代表 implementation 實現）
我們看一下NSObject_IMPL內部
struct NSObject_IMPL {
Class isa;
};
// 查看Class本質
typedef struct objc_class *Class;
我們發現Class其實就是一個指針，對象底層實現其實就是這個樣子。
思考： 一個OC對象在內存中是如何布局的。
NSObjcet的底層實現，點擊NSObjcet進入發現NSObject的內部實現
@interface NSObject <NSObject> {
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Wobjc-interface-ivars"
Class isa OBJC_ISA_AVAILABILITY;
#pragma clang diagnostic pop
}
@end
轉化為c語言其實就是一個結構體
struct NSObject_IMPL {
Class isa;
};
上圖實際上NSObject對象中存在一個isa指針，isa指針在64位系統中占用8個字節，在32位的系統中占用4個字節，目前用的是64位系統，所以在我們NSObject中isa指針會占用8個字節。CLass isa的內部實現為結構體。
為了探尋OC對象在內存中如何體現，我們來看下面一段代碼
/// 創建并分配存儲空間
NSObject *objc = [[NSObject alloc] init];
假設我們NSObject對象分配了一塊存儲空間，假設之后8個字節，在這8個字節中我們只放了isa指針，假設我們的isa的地址為0x100400110，這個isa的地址就是結構體的地址。所以說obj的地址就是0x100400110。
1.3: NSObject占用的內存
#import <malloc/malloc.h>
#import <OBJC/runtime.h>
///> main
int main(int argc, char * argv[]) {
@autoreleasepool {
NSObject *obj = [[NSObject alloc]init];
///> 獲得NSObject類的實例對象的大小
NSLog(@"%zd", class_getInstanceSize([NSObject class]));
///> 獲取obj指針指向內存的大小
NSLog(@"%zd", malloc_size((__bridge const void *)obj));
/**輸出結果
8
16
*/
}
return 0;
}
-
首先我們用的
Runtime的class_getInstanceSize()方法去查看 NSObject類的實例對象的大小- 傳入類
class - 注意:
Instance實例，返回一個類的實例大小占用了內存空間的大小為8
- 傳入類
-
然后我們用
malloc_size的方法去查看obj指針指向內存的大小為16；- 傳入obj的指針（會有錯誤提示 然后寫上橋接就好了(__bridge const void *) ）
malloc_size 為什么是16接下來我們可以去查看源碼去解決問題： 源碼地址：Source Browser:OBJective-c源碼 找到objc4，下載版本號最大的就是最新的源碼去查看
)
接下來我們去閱讀源碼。
二：自定義類的內部實現
@interface Student : NSObject{
@public
int _no;
int _age;
}
@end
@implementation Student
int main(int argc, const char * argv[]) {
@autoreleasepool {
Student *stu = [[Student alloc] init];
stu -> _no = 4;
stu -> _age = 5;
NSLog(@"%@",stu);
}
return 0;
}
@end
按照上述步驟同樣生成c++文件。并查找Student，我們發現Student_IMPL
struct Student_IMPL {
struct NSObject_IMPL NSObject_IVARS;
int _no;
int _age;
};
發現第一個是 NSObject_IMPL的實現。而通過上面的實驗我們知道NSObject_IMPL內部其實就是Class isa
那么我們假設 struct NSObject_IMPL NSObject_IVARS; 等價于 Class isa
可以將上述代碼轉化為
struct Student_IMPL {
Class *isa;
int _no;
int _age;
};
因此此結構體占用多少存儲空間，對象就占用多少存儲空間。因此結構體占用的存儲空間為，isa指針8個字節空間+int類型_no4個字節空間+int類型_age4個字節空間共16個字節空間
Student *stu = [[Student alloc] init];
stu -> _no = 4;
stu -> _age = 5;
那么上述代碼實際上在內存中的體現為，創建Student對象首先會分配16個字節，存儲3個東西，isa指針8個字節，4個字節的_no ,4個字節的_age
sutdent對象的3個變量分別有自己的地址。而stu指向isa指針的地址。因此stu的地址為0x100400110，stu對象在內存中占用16個字節的空間。并且經過賦值，_no里面存儲4 ，_age里面存儲5
驗證Student在內存中模樣
struct Student_IMPL {
Class isa;
int _no;
int _age;
};
@interface Student : NSObject
{
@public
int _no;
int _age;
}
@end
@implementation Student
int main(int argc, const char * argv[]) {
@autoreleasepool {
// 強制轉化
struct Student_IMPL *stuImpl = (__bridge struct Student_IMPL *)stu;
NSLog(@"_no = %d, _age = %d", stuImpl->_no, stuImpl->_age); // 打印出 _no = 4, _age = 5
}
return 0;
}
上述代碼將oc對象強轉成Student_IMPL的結構體。也就是說把一個指向oc對象的指針，指向這種結構體。由于我們之前猜想，對象在內存中的布局與結構體在內存中的布局相同，那么如果可以轉化成功，說明我們的猜想正確。由此說明stu這個對象指向的內存確實是一個結構體。
實際上想要獲取對象占用內存的大小，可以通過更便捷的運行時方法來獲取。
class_getInstanceSize([Student class])
NSLog(@"%zd,%zd", class_getInstanceSize([NSObject class]) ,class_getInstanceSize([Student class]));
// 打印信息 8和16
三: 閱讀源碼窺探類的創建過程
3.1 下載源碼
閱讀runtime的源碼https://opensource.apple.com/tarballs/objc4/
3.2 找尋類的創建過程
-
a. 根據
alloc方法尋找創建流程 我們可以在源碼NSObject.mm找到+ (id)alloc { return _objc_rootAlloc(self); } -
b. 我們可以看到
_objc_rootAlloc實際調用的是callAlloc// 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*/); }這個注釋很有意思 聲明這是基類的對alloc的實現 這個時候
cls不能為空。 -
c. 我們可以詳細看看
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 __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)); }
因為我們當前的OC語言版本是2.0 所以我們可以著重去分析當前這塊代碼`_objc_rootAllocWithZone`, 通過名字就可以看出這是基類真正開辟空間的方法
```
#if __OBJC2__
if (slowpath(checkNil && !cls)) return nil;
if (fastpath(!cls->ISA()->hasCustomAWZ())) {
return _objc_rootAllocWithZone(cls, nil);
}
#endif
```
-
d. 在開源工程里面搜尋
objc-runtime-new.mm這個文件里面可以看到NEVER_INLINE id _objc_rootAllocWithZone(Class cls, malloc_zone_t *zone __unused) { // allocWithZone under __OBJC2__ ignores the zone parameter return _class_createInstanceFromZone(cls, 0, nil, OBJECT_CONSTRUCT_CALL_BADALLOC); } -
e. 根據調用關系 我們接茬找
_class_createInstanceFromZonestatic 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); }通過閱讀源碼我們可以看出這個方法的主要做了幾個方面的操作
- 1: 判斷當前對象的狀態，做一些非空校驗、鎖校驗等等操作保證后面創建的空間過程中依賴數據的正常
- 2: 計算需要類的元素的尺寸
cls->instanceSize - 3: 調用
malloc_zone_calloc或者calloc實現真實的創建 - 4: 將指針賦值給isa指針和引用計數的處理操作
針對第一步的前期準備我們不做詳細討論 我們直接去看類的空間計算也就是主要看
instanceSize -
f. 在
objc-runtime-new.h找到這個方法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; }前面傳遞的額外數據是0 所以我們需要詳細分析
alignedInstanceSize方法. 這個方法主要是用于計算當前的類成員變量占據的大小
?? 分配類對象的大小并非是類對象需要幾個字節就分配幾個字節 需要做字節對齊和編譯器優化等等操作。 同時告訴我們如果占據的空間小于16個字節 分配16個字節就是為了性能和管理做的折中。
-
g. 繼續查找
alignedInstanceSize看注釋可以明白 這個方法計算當前的類的成員變量占據的空間尺寸// Class's ivar size rounded up to a pointer-size boundary. uint32_t alignedInstanceSize() const { return word_align(unalignedInstanceSize()); }
class_getInstanceSize 獲取NSObject類的實例對象變量所占用的空間大小
malloc_size() 獲取指針指向內存的大小
四: 窺探內存結構
實時查看內存數據
方式一：通過打斷點。
Debug Workflow -> viewMemory address中輸入stu的地址
從上圖中，我們可以發現讀取數據從高位數據開始讀，查看前16位字節，每四個字節讀出的數據為
16進制 0x0000004(4字節) 0x0000005(4字節) isa的地址為 00D1081000001119(8字節)
方式二：通過lldb指令xcode自帶的調試器
memory read 0x10074c450
// 簡寫 x 0x10074c450
// 增加讀取條件
// memory read/數量格式字節數 內存地址
// 簡寫 x/數量格式字節數 內存地址
// 格式 x是16進制，f是浮點，d是10進制
// 字節大小 b：byte 1字節，h：half word 2字節，w：word 4字節，g：giant word 8字節
示例：x/4xw // /后面表示如何讀取數據 w表示4個字節4個字節讀取，x表示以16進制的方式讀取數據，4則表示讀取4次
同時也可以通過lldb修改內存中的值
memory write 0x100400c68 6
將_no的值改為了6
那么一個NSObject對象占用多少內存？
NSObjcet實際上是只有一個名為isa的指針的結構體，因此占用一個指針變量所占用的內存空間大小，如果64bit占用8個字節，如果32bit占用4個字節。
更復雜的繼承關系
面試題：在64bit環境下， 下面代碼的輸出內容？
/* Person */
@interface Person : NSObject
{
int _age;
}
@end
@implementation Person
@end
/* Student */
@interface Student : Person
{
int _no;
}
@end
@implementation Student
@end
int main(int argc, const char * argv[]) {
@autoreleasepool {
NSLog(@"%zd %zd",
class_getInstanceSize([Person class]),
class_getInstanceSize([Student class])
);
}
return 0;
}
這道面試題的實質是想問一個Person對象，一個Student對象分別占用多少內存空間？
我們依據上面的分析與發現，類對象實質上是以結構體的形式存儲在內存中，畫出真正的內存圖例
我們發現只要是繼承自NSObject的對象，那么底層結構體內一定有一個isa指針。
那么他們所占的內存空間是多少呢？單純的將指針和成員變量所占的內存相加即可嗎？上述代碼實際打印的內容是16 16，也就是說，person對象和student對象所占用的內存空間都為16個字節。
其實實際上person對象確實只使用了12個字節。但是因為內存對齊的原因。使person對象也占用16個字節。
編譯器在給結構體開辟空間時，首先找到結構體中最寬的基本數據類型，然后尋找內存地址能是該基本數據類型的整倍的位置，作為結構體的首地址。將這個最寬的基本數據類型的大小作為對齊模數。
為結構體的一個成員開辟空間之前，編譯器首先檢查預開辟空間的首地址相對于結構體首地址的偏移是否是本成員的整數倍，若是，則存放本成員，反之，則在本成員和上一個成員之間填充一定的字節，以達到整數倍的要求，也就是將預開辟空間的首地址后移幾個字節。
我們可以總結內存對齊為兩個原則：
原則 1. 前面的地址必須是后面的地址正數倍,不是就補齊。
原則 2. 整個Struct的地址必須是最大字節的整數倍。
通過上述內存對齊的原則我們來看，person對象的第一個地址要存放isa指針需要8個字節，第二個地址要存放_age成員變量需要4個字節，根據原則一，8是4的整數倍，符合原則一，不需要補齊。然后檢查原則2，目前person對象共占據12個字節的內存，不是最大字節數8個字節的整數倍，所以需要補齊4個字節，因此person對象就占用16個字節空間。
而對于student對象，我們知道sutdent對象中，包含person對象的結構體實現，和一個int類型的_no成員變量，同樣isa指針8個字節，_age成員變量4個字節，_no成員變量4個字節，剛好滿足原則1和原則2，所以student對象占據的內存空間也是16個字節。
