由于大家使用的网络和设备条件各不相同，无法保证按照该教程操作一定能成功😂 最近问的人比较多，所以做个统一整理，仅供参考~

• 可能面临的财产损失（包括但不限于），请务必知悉：
  • 注册美区账号后，成功充值了礼品卡，但无法使用礼品卡购买ChatGPT Plus，且，已充值的服务卡不支持退费（损失礼品卡费用）。
  • 充值成功，但账号被ChatGPT官方检测为异常，导致账号被封禁（丢失账号+损失充值费）。
• 教程来自网络搜集，部分操作可能随软件功能更新而失效，所以，想充值的请尽快~
• 成功充值ChatGPT Plus后，就能同时在ChatGPT APP和ChatGPT网页端，使用GPT-4啦！
• 每月费用：20美金
• 一个观点：是否充值主要看个人需求，如果觉得3.5给出的答复已经令人满意，那就继续使用。如果感觉每月20刀也不算啥不愿负担的成本，那么不妨开上一月试试。

以下是购买ChatGPT Plus会员的两种方案

方案1：iOS渠道使用支付宝购买

1. 工具清单：

• 支付宝账号
• 一个给力的可以访问ChatGTP的电脑（出国自行查询）
• 一个ChatGTP账号
• 一台IPhone or IPad：因为需要使用移动端APP Store，Mac似乎不行。
• 一个美区 App Store 账号：注册教程可参考：

2. 操作步骤：
   当你拥有以上所有工具后，可参考以下操作步骤：

• 在你的IPhone/IPad上退出中国区账号，登录美区账号。
• 登录美区账号后，在App Store搜索ChatGPT，完成下载安装。
• 通过支付宝，充值美区App Store礼品卡（共20美金），具体步骤可参考：
• 打开ChatGPT软件，登录账号后，付费升级ChatGPT Plus，操作步骤可参考：
• 完成升级后，你可以直接在PC网页端登录ChatGPT账号，勾选CPT-4进行使用~

3. 注意事项：

• 1个美区AppStore账号只能绑定一个ChatGPT账号（有6个月锁定期）
• 充值完成后，APP页面显示有延迟，即：明明付钱了，软件也提示你完成订阅了，但subscription 仍显示为 Free，用不了GPT-4，此时，可退出软件重进 or 撂下手机等待一段时间，软件会在稍后更新订阅情况。

  方案2：Wildcard虚拟卡充值

1. 工具清单：

• Wildcard虚拟卡，注册链接：

2. 操作步骤：
   Wildcard官网有很详细的图文和视频教程，这里不再赘述。
   参考教程：
   ChatGPT Plus 订阅教程 | WildCard 帮助中心
   WildCard 开通 ChatGPT Plus 详细教程_哔哩哔哩_bilibili
   ChatGPT Plus 如何只订阅1个月 | WildCard 帮助中心

常见问题1：订阅需要排队怎么办？

点击upgrade后，如果出现以下界面提示需要排队开通，则可以采用下面的步骤跳过排队。

1. 关闭这个界面；
2. 按下F12，打开控制台（console），输入如下代码：

   1 2 3 4 5 6

   fetch("/api/auth/session").then(r => r.json()).then(({ accessToken }) => { fetch("/backend-api/payments/checkout", { "method": "POST", "headers": {"authorization": `Bearer ${accessToken}`,}, }).then(r => r.json()).then(d => window.open(d.url)) })

   
3. 自动跳转到付款界面：
   

   常见问题2：付款不成功怎么办？比如弹出“我们未能验证您的支付方式。请选择另一支付方式并重试”

   最简单有效的办法是找网站客服帮忙订阅，我就是本地环境与登录远程环境都重试多次均不成功，找客服让他们的海外同事开通了
   需要准备：

• 你的OpenAI账号和密码
• 你的wildcard卡片和账单地址的全部信息（点击「复制全部」按钮即可）
  
• 开头的那个全部网址，点击 Upgrade 跳转后的那个ChatGPT的付款页面
• 

点击右下角对话图标即可唤起客服，把 OpenAI 的账户密码提供给客服，让他们的海外同事帮您进行绑定，成功率接近100%。

注意事项：

1张虚拟卡最多可以给4个ChatGPT 账号开通Plus，如果超出数量，可以点击“多卡”，申请一张新卡

安卓手机如何下载安装ChatGPT？

安卓手机需要先安装谷歌三件套，安装完成后即可进入Play商店搜索ChatGPT下载。
安装谷歌三件套视频教程：
Google Play 下载链接：

• alloc源码分析中的align16：
• malloc源码分析中的segregated_size_to_fit

align16： 16字节对齐算法

1
2
3

static inline size_t align16(size_t x) {
    return (x + size_t(15)) & ~size_t(15);
}

• 首先将原始的内存 8 与 size_t(15)相加，得到 8 + 15 = 23
• 将 size_t(15) 即 15进行~（取反）操作，~（取反）的规则是：1变为0，0变为1
• 最后将 23 与 15的取反结果 进行 &（与）操作，&（与）的规则是：都是1为1，反之为0，最后的结果为 16，即内存的大小是以16的倍数增加的

segregated_size_to_fit： 16字节对齐算法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

#define SHIFT_NANO_QUANTUM4
#define NANO_REGIME_QUANTA_SIZE(1 << SHIFT_NANO_QUANTUM)// 16

static MALLOC_INLINE size_t
segregated_size_to_fit(nanozone_t *nanozone, size_t size, size_t *pKey)
{
size_t k, slot_bytes;

if (0 == size) {
size = NANO_REGIME_QUANTA_SIZE; // Historical behavior
}
k = (size + NANO_REGIME_QUANTA_SIZE - 1) >> SHIFT_NANO_QUANTUM; // round up and shift for number of quanta
slot_bytes = k << SHIFT_NANO_QUANTUM;// multiply by power of two quanta size
*pKey = k - 1;// Zero-based!

return slot_bytes;
}

算法原理：
k + 15 >> 4 << 4 ，其中 右移4 + 左移4 相当于将后4位抹零，跟 k/16 * 16一样 ，是16字节对齐算法，小于16就成0了
以 k = 2为例，如下图所示

在开始探究内存对齐原理之前，我们先来两个问题：

1. 内存对齐原则是什么？

• 数据成员对齐规则：结构体（struct）或联合体（union）的数据成员，第一个数据成员放在 offset 为 0 的地方，以后每个数据成员存储的起始位置要从该成员大小或者成员的子成员大小（只要该成员有子成员，比如说数组、结构体等）的整数倍开始（比如int为4字节，则要从4的整数倍地址开始存储）
• 结构体作为成员：如果一个结构里有某些结构体成员，则结构体成员要从其内部最大元素大小的整数倍地址开始存储（strcut a里存有 struct b，b里有结构体char，int 等，那么b应该从8的整数倍开始存储）
• 结构体的总大小，也就是sizeof的结果，必须是其内部最大成员的整数倍，不足的需要补齐

2. 获取内存大小的方法有哪些？

• sizeof
• class_getInstanceSize
• malloc_size

下面我们通过程序运行来看一下三种获取内存大小的方法有什么不同：

1
2
3
4
5
6
7
8
9
10
11
12
13

#import <Foundation/Foundation.h>
#import <objc/runtime.h>
#import <malloc/malloc.h>

int main(int argc, const char * argv[]) {
    @autoreleasepool {
        NSObject *objc = [[NSObject alloc] init];
        NSLog(@"objc对象类型占用的内存大小：%lu",sizeof(objc));
        NSLog(@"objc对象实际占用的内存大小：%lu",class_getInstanceSize([objc class]));
        NSLog(@"objc对象实际分配的内存大小：%lu",malloc_size((__bridge const void*)(objc)));
    }
    return 0;
}

输出结果分别为

1
2
3

objc对象类型占用的内存大小：8
objc对象实际占用的内存大小：8
objc对象实际分配的内存大小：16

由上述结果我们可得出并验证：

• sizeof：计算类型占用的内存大小，其中可以放基本数据类型、对象、指针，对于类似于int这样的基本数据而言，sizeof获取的就是数据类型占用的内存大小，不同的数据类型所占用的内存大小是不一样的，而对于类似于NSObject定义的实例对象而言，其对象类型的本质就是一个结构体（即 struct objc_object）的指针，所以sizeof(objc)打印的是对象objc的指针大小，我们知道一个指针的内存大小是8，所以sizeof(objc) 打印是 8。(注意：这里的8字节与isa指针一点关系都没有!)，对于指针而言，sizeof打印的就是8，因为一个指针的内存大小是8，
• class_getInstanceSize：计算对象实际占用的内存大小，这个需要依据类的属性而变化，如果自定义类没有自定义属性，仅仅只是继承自NSObject，则类的实例对象实际占用的内存大小是8，可以简单理解为8字节对齐
• malloc_size：计算对象实际分配的内存大小，这个是由系统完成的，可以从上面的打印结果看出，实际分配的和实际占用的内存大小并不相等，具体可参考并了解源码分析中的16字节对齐算法来解释这个问题

结构体内存对齐

下面我们开始进入正题：内存对齐原理的探究
众所周知，结构体和类的内存对齐方式类似，接下来，我们通过两个结构体来展开内存对齐原理的探究：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

//1、定义两个结构体
struct Mystruct1{
    char a;     //1字节
    double b;   //8字节
    int c;      //4字节
    short d;    //2字节
}Mystruct1;

struct Mystruct2{
    double b;   //8字节
    int c;      //4字节
    short d;    //2字节
    char a;     //1字节
}Mystruct2;

//计算 结构体占用的内存大小
NSLog(@"%lu-%lu",sizeof(Mystruct1),sizeof(Mystruct2));

上述两个结构体，通过控制台打印输出分别得到sizeof(Mystruct1)=24，sizeof(Mystruct2)=16，那么两个变量及变量类型都相同的结构体，仅仅是排列顺序不同，他们所占用的内存大小为什么不一样呢？这就是我们所要探究的内存字节对齐现象
通过文章开头内存对齐原则计算MyStruct1的内存大小，详解过程如下：

• 变量a：占1个字节，从0开始，此时min（0，1），即 0 存储 a
• 变量b：占8个字节，从1开始，此时min（1，8），1不能整除8，继续往后移动，知道min（8，8），从8开始，即 8-15 存储 b
• 变量c：占4个字节，从16开始，此时min（16，4），16可以整除4，即 16-19 存储 c
• 变量d：占2个字节，从20开始，此时min(20, 2)，20可以整除2，即20-21 存储 d

因此MyStruct1的需要的内存大小为 15字节，而MyStruct1中最大变量的字节数为8，所以 MyStruct1 实际的内存大小必须是 8 的整数倍，21向上取整到24，主要是因为24是8的整数倍，所以 sizeof(MyStruct1) 的结果是 24

根据内存对齐规则计算MyStruct2的内存大小，详解过程如下：

• 变量b：占8个字节，从0开始，此时min（0，8），即 0-7 存储 b
• 变量c：占4个字节，从8开始，此时min（8，4），8可以整除4，即 8-11 存储 c
• 变量d：占2个字节，从12开始，此时min(12, 2)，12可以整除2，即12-13 存储 d
• 变量a：占1个字节，从14开始，此时min（14，1），即 14 存储 a

因此MyStruct2的需要的内存大小为 15字节，而MyStruct1中最大变量的字节数为8，所以 MyStruct2 实际的内存大小必须是 8 的整数倍，15向上取整到16，主要是因为16是8的整数倍，所以 sizeof(MyStruct2) 的结果是 16

结构体嵌套结构体

上面的两个结构体只是简单的定义数据成员，下面来一个比较复杂的，结构体中嵌套结构体的内存大小计算情况

1
2
3
4
5
6
7
8
9
10
11
12

//1、结构体嵌套结构体
struct Mystruct3{
    double b;   //8字节
    int c;      //4字节
    short d;    //2字节
    char a;     //1字节
    struct Mystruct2 str; 
}Mystruct3;

//2、打印 Mystruct3 的内存大小
NSLog(@"Mystruct3内存大小：%lu", sizeof(Mystruct3));
NSLog(@"Mystruct3中结构体成员内存大小：%lu", sizeof(Mystruct3.str));

分析Mystruct3的内存计算
根据内存对齐规则，来一步一步分析Mystruct3内存大小的计算过程

• 变量b：占8个字节，从0开始，此时min（0，8），即 0-7 存储 b
• 变量c：占4个字节，从8开始，此时min（8，4），8可以整除4，即 8-11 存储 c
• 变量d：占2个字节，从12开始，此时min(12, 2)，20可以整除2，即12-13 存储 d
• 变量a：占1个字节，从14开始，此时min（14，1），即 14 存储 a
• 结构体成员str：str是一个结构体，根据内存对齐原则二，结构体成员要从其内部最大成员大小的整数倍开始存储，而MyStruct2中最大的成员大小为8，所以str要从8的整数倍开始，当前是从15开始，所以不符合要求，需要往后移动到16，16是8的整数倍，符合内存对齐原则，所以 16-31 存储 str

因此MyStruct3的需要的内存大小为 32字节，而MyStruct3中最大变量为str, 其最大成员内存字节数为8，根据内存对齐原则，所以 MyStruct3 实际的内存大小必须是 8 的整数倍，32正好是8的整数倍，所以 sizeof(MyStruct3) 的结果是 32

其内存存储情况如下图所示

1
2
3
4
5
6

GJPerson *objc1 = [GJPerson alloc];
GJPerson *objc2 = [objc1 init];
GJPerson *objc3 = [objc1 init];
NSLog(@"%@ - %p - %p", objc1, objc1, &objc1);
NSLog(@"%@ - %p - %p", objc2, objc2, &objc2);
NSLog(@"%@ - %p - %p", objc3, objc3, &objc3);

以上3条输出语句分别输出了3个对象的内容、内存地址、指针地址，他们的值又会是什么呢？是否相同呢？

验证结果如下图：

从验证结果可知，3个对象指向的是同一内存空间，所以其内容和内存地址都是相同的，但是指针地址是不同的
从而我们可以初步的推断出，alloc开辟了内存空间，init将指针指向alloc开辟的内存空间中！

下面我们就来深入的了解一下alloc，init，new ~

alloc源码探究

准备工作：
下载objc4源码
编译源码，可自行进行百度、google、github，网上有详细的编译教程以及可编译程序，就不多加赘述了

alloc + init 整体源码的执行流程如下图：

通过断点调试源码可知，alloc实现主要分为以下几个步骤：

第一步：alloc 方法

1
2
3

+ (id)alloc {
    return _objc_rootAlloc(self);
}

第二步：_objc_rootAlloc 方法

1
2
3
4
5

id
_objc_rootAlloc(Class cls)
{
    return callAlloc(cls, false/*checkNil*/, true/*allocWithZone*/);
}

第三步：callAlloc 方法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

static ALWAYS_INLINE id
callAlloc(Class cls, bool checkNil, bool allocWithZone=false)// alloc 源码 第三步
{
#if __OBJC2__ //有可用的编译器优化
    /*
fastpath slowpath参考链接：https://www.jianshu.com/p/536824702ab6
checkNil 为false，!cls 也为false ，所以slowpath 为 false，假值判断不会走到if里面，即不会返回nil
     */
    if (slowpath(checkNil && !cls)) return nil;
    
    // 判断一个类是否有自定义的 +allocWithZone 实现，没有则走到if里面的实现
    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));
}

第四步：通过断点调试执行了_objc_rootAllocWithZone方法，这部分是alloc源码的核心操作，由下面的流程图及源码可知，该方法的实现主要分为三部分

• cls->instanceSize：计算需要开辟的内存空间大小
• calloc：申请内存，返回地址指针
• obj->initInstanceIsa：将 类 与 isa 关联

  1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49

  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)// alloc 源码 第五步 { 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; //计算需要开辟的内存大小，传入的extraBytes 为 0 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) { //将 cls类 与 obj指针（即isa） 关联 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); }

  cls->instanceSize：计算所需内存大小

  
• instanceSize的源码实现

  1 2 3 4 5 6 7 8 9 10 11 12 13

  size_t instanceSize(size_t extraBytes) const { //编译器快速计算内存大小 if (fastpath(cache.hasFastInstanceSize(extraBytes))) { return cache.fastInstanceSize(extraBytes); } // 计算类中所有属性的大小 + 额外的字节数0 size_t size = alignedInstanceSize() + extraBytes; // CF requires all objects be at least 16 bytes. //如果size 小于 16，最小取16 if (size < 16) size = 16; return size; }

• fastInstanceSize的源码实现

  1 2 3 4 5 6 7 8 9 10 11 12 13 14 15

  size_t fastInstanceSize(size_t extra) const { ASSERT(hasFastInstanceSize(extra)); //Gcc的内建函数 __builtin_constant_p 用于判断一个值是否为编译时常数，如果参数EXP 的值是常数，函数返回 1，否则返回 0 if (__builtin_constant_p(extra) && extra == 0) { return _flags & FAST_CACHE_ALLOC_MASK16; } else { size_t size = _flags & FAST_CACHE_ALLOC_MASK; // remove the FAST_CACHE_ALLOC_DELTA16 that was added // by setFastInstanceSize //删除由setFastInstanceSize添加的FAST_CACHE_ALLOC_DELTA16 8个字节 return align16(size + extra - FAST_CACHE_ALLOC_DELTA16); } }

  align16内存字节对齐原则
  //16字节对齐算法
  static inline size_t align16(size_t x) {
  return (x + size_t(15)) & ~size_t(15);
  }

内存字节对齐原则

在解释为什么需要16字节对齐之前，首先需要了解内存字节对齐的原则，主要有以下三点

• 数据成员对齐规则：struct 或者 union 的数据成员，第一个数据成员放在offset为0的地方，以后每个数据成员存储的起始位置要从该成员大小或者成员的子成员大小（只要该成员有子成员，比如数据、结构体等）的整数倍开始（例如int在32位机中是4字节，则要从4的整数倍地址开始存储）
• 数据成员为结构体：如果一个结构里有某些结构体成员，则结构体成员要从其内部最大元素大小的整数倍地址开始存储（例如：struct a里面存有struct b，b里面有char、int、double等元素，则b应该从8的整数倍开始存储）
• 结构体的整体对齐规则：结构体的总大小，即sizeof的结果，必须是其内部做大成员的整数倍，不足的要补齐

为什么需要16字节对齐

需要字节对齐的原因，有以下几点：

• 通常内存是由一个个字节组成的，cpu在存取数据时，并不是以字节为单位存储，而是以块为单位存取，块的大小为内存存取力度。频繁存取字节未对齐的数据，会极大降低cpu的性能，所以可以通过减少存取次数来降低cpu的开销
• 16字节对齐，是由于在一个对象中，第一个属性isa占8字节，当然一个对象肯定还有其他属性，当无属性时，会预留8字节，即16字节对齐，如果不预留，相当于这个对象的isa和其他对象的isa紧挨着，容易造成访问混乱
• 16字节对齐后，可以加快CPU读取速度，同时使访问更安全，不会产生访问混乱的情况

calloc：申请内存，返回地址指针

此时并没有与obj对象进行关联，只是返回了地址指针

obj->initInstanceIsa：类与isa关联

将上述得到的地址指针与obj进行关联

到此alloc执行就已经结束了 ~

init 源码探索

类方法实现init

1
2
3

+ (id)init {
    return (id)self;
}

这里的init是一个构造方法 ，是通过工厂设计（工厂方法模式）,主要是用于给用户提供构造方法入口。这里能使用id强转的原因，主要还是因为 内存字节对齐后，可以使用类型强转为你所需的类型

new 源码探索

1
2
3

+ (id)new {
    return [callAlloc(self, false/*checkNil*/) init];
}

从以上代码可以看出，new方法实际上等价与[[xxx alloc] init]，鉴于开发过程中通常会重写init方法做一些自定义的操作，所以不建议使用new方法

注：
1.如果子类没有重写父类的init，new会调用父类的init方法
2.如果子类重写了父类的init，new会调用子类重写的init方法
3.如果使用 alloc + 自定义的init，可以帮助我们自定义初始化操作，例如传入一些子类所需参数等，最终也会走到父类的init，相比new而言，扩展性更好，更灵活。

1. 在日常开发中我们经常会用到LLDB调试，比如：p xxx，po xxx，bt等等，这些调试命令的作用都是什么呢？
2. 源码探索对于开发来说也是一件必须要掌握的事情，源码探索的方法又有哪些呢？

下面针对这两点，我们将一一进行解释说明！

LLDB常用调试命令集合

1. p和po命令

• p 命令： print 命令的简写，使用p 命令可以查看基本数据类型的值；如果使用p命令查看的是对象，那么只会返回对象的指针地址。 p命令后面除了可以接变量、常量，还可以接表达式。
• po 命令：print object的缩写，可以理解为打印对象。功能与p命令类似，也可以打印常量、变量，打印表达式返回的对象等。
  

  p 和 po 的区别在于使用 po 只会输出对应的值，而 p 则会返回值的类型以及命令结果的引用名。

ps: 使用p做进制转换

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

//默认打印为10进制
(lldb) p 20
(int) $0 = 20
//转16进制
(lldb) p/x 10
(int) $1 = 0x0000000a
//转8进制
(lldb) p/o 10
(int) $2 = 012
//转二进制
(lldb) p/t 10
(int) $3 = 0b00000000000000000000000000001010
//字符转10进制数字
(lldb) p/d 'A'
(char) $4 = 65
//10进制数字转字符
(lldb) p/c 66
(int) $5 = B\0\0\0

2. bt命令（thread backtrace堆栈打印简写）

• bt命令可以打印出线程的堆栈信息，bt命令是打印当前线程的堆栈信息，如下图所示。该信息比左侧的Debug Navigator 看到的还要详细一些。如果嫌堆栈打印太长，可以加一个值限制，如bt 10。
  
• bt all 命令可以打印所有线程的堆栈信息。
  

3. 内存读取命令

• x命令就是memory read内存读取并打印的作用， x是读取内存的命令
  
• x/4gx中第一个x是读取内存命令，后面的g是每次读取8字节，x的意思是16进制显示结果，4表示连续打印4段。
• 对于g，常用的大小格式为b对应byte 1字节，h对应half word 2字节，w对应word 4字节，g对应giant word 8字节
• 对于x，我们还可以用o对应8机制，b对应2进制,x对应16进制,f对应浮点，d对应10进制。
  

4. thread list命令

• 用于列出所有线程，如下图所示，其中星号(*)表示thread#1为当前线程。
  

5. 待续。。。

源码探索的的三种方法

• 打符号断点方式调试流程
• 通过按住control+step into按钮逐步进入调试
• 汇编源码跟流程

1. 打符号断点方式调试流程

选择编译器调试中的Symbolic Breakpoint断点调试
例如：探索alloc方法，添加Symbolic Breakpoint断点，即可查看到alloc源码位于libobjc.A.dylib库中，如下图：

2. 通过按住control+step into按钮逐步进入调试

在相应的alloc处打上断点，当执行到断点处时，按下control+step into即可逐步调试


调试结果依然可以看到alloc源码位于libobjc.A.dylib库中

3. 汇编源码跟流程

xcode 工具栏 选择 Debug –> Debug Workflow –> Always Show Disassembly,这个 选项表示 始终显示反汇编 ，即 通过汇编 跟流程
调试结果同方法2，依然可以看到objc_alloc，从而得到alloc源码位于libobjc.A.dylib库中

ps:注意（以下是Apple 提供的源码下载地址）：
1、Apple 所有开源源码汇总地址，根据相应的版本查找对应的源码，以mac 10.15为例: macOS --> 10.15 --> 选择10.15 --> 搜索 objc
2、Apple 比较直接的源码下载地址，直接搜索想要下载的源码名称即可，例如objc：直接搜索 objc --> objc4/ --> 选择相应的objc的版本

创建公有Pod库或者私有Pod库, 实际上原理是一样的, 都是基于git服务和repo协议, 不一样的是, 两者的版本索引查询方式不一样, 公有库的podspec由CocoaPods/Specs管理, 而内部私有使用的pod库需要自己建立一个仓库来管理podspec.

1
2
3

// 创建pod库
// 例如：pod lib create GJNotifyView
pod lib create [repo-name]

回车之后，终端会询问你几个哲学的问题

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

# 选择编程语言
What language do you want to use?? [ Swift / ObjC ]
> Objc  

# 在你的项目中是否创建一个demo工程，为了方便测试，我选择了Yes
Would you like to include a demo application with your library? [ Yes / No ]
 > Yes  

# 测试框架选择哪一个
Which testing frameworks will you use? [ Specta / Kiwi / None ]
 > None

# 要不要做视图测试
Would you like to do view based testing? [ Yes / No ]
 > Yes

# 类前缀名
What is your class prefix?
 > GJ

pod项目安装

1
2

// 安装CocoaPods项目
pod install --no-repo-update

• 将项目添加到库的Classes文件夹中

编辑CocoaPods的配置文件（后缀名为podspec)

pod项目更新

1
2

// 更新CocoaPods项目
pod update --no-repo-update

验证pod配置文件

1
2

// 验证pod配置文件
pod lib lint

发布项目

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

# 添加远程地址,即上面创建码云项目的地址
BetterdeMacBook-Pro:PrivateHelloWorld better$ git remote add origin https://gitee.com/Better_Y/PrintHelloWorld.git
# 添加文件
BetterdeMacBook-Pro:PrivateHelloWorld better$ git add .
# 提交本地，并写描述
BetterdeMacBook-Pro:PrivateHelloWorld better$ git commit -a -m "第一次提交 版本为0.0.1"
# --allow-unrelated-histories
# git pull origin maste会失败 ,提示：fatal: refusing to merge unrelated histories
# 原因是远程仓库origin上的分支master和本地分支master被Git认为是不同的仓库，所以不能直接合并，需要添加 --allow-unrelated-histories

BetterdeMacBook-Pro:PrivateHelloWorld better$ git pull origin master --allow-unrelated-histories
# 推送到码云的PrintHelloWolrd项目的master分支上
BetterdeMacBook-Pro:PrivateHelloWorld better$ git push origin master
# 提交版本号
BetterdeMacBook-Pro:PrivateHelloWorld better$ git tag 0.0.1
# push到远程分支
BetterdeMacBook-Pro:PrivateHelloWorld better$ git push origin 0.0.1

创建并发布Sepc管理库

1
2
3
4
5
6

// 创建Sepc
pod repo add [repo-name] [git-url]
// 发布
pod repo push [repo-name] [name.podspec]
// 删除
pod repo remove [repo-name]

使用Cocoapods私有库

• 指定其他工程的Podfile文件中source字段为私有仓库repo仓库地址

  1	pod 'repo-name', :source=>'cocoapods-repo-url'

JKCategories(iOS-Categories)，一个有用的Objective-C类别的集合，扩展了iOS框架，如Foundation、UIKit、CoreData、QuartzCore、CoreLocation、MapKit等。

Requirements

此库需要iOS 7.0+和Xcode 8.0+。

Installation

安装椰荚

使用“所有类别”时：

1
2

platform :ios
pod 'JKCategories'

当您要使用某种类型的框架库时，例如Foundation：

1
2

platform :ios
pod 'JKCategories/Foundation'

当您要使用更详细的类类型库时，在某个单类型框架库中，例如Foundation's NSDictionary：

1
2

platform :ios
pod 'JKCategories/Foundation/NSDictionary'

您将找到带有pod search JKCategories或Podfile或项目文件夹层次结构中的所有子库

Manually

将JKCategories或某些特定的类文件复制到项目中

Usage

将头文件导入任何希望使用诸如

1

#import "NSArray+JKSafeAccess.h" or "<JKCategories/NSArray+JKSafeAccess.h>"

不建议将JKCategories的所有头文件导入pch或baseclass

onekey导入所有类别的框架

1
2
3
4
5
6

"JKUIKit.h" or "<JKCategories/JKUIKit.h>",
"JKFoundation.h" or "<JKCategories/JKFoundation.h>",
"JKCoreData.h" or "<JKCategories/JKCoreData.h>",
"JKCoreLocation.h" or "<JKCategories/JKCoreLocation.h>",
"JKMapKit.h"  or "<JKCategories/JKMapKit.h>",
"JKQuartzCore.h"  or "<JKCategories/JKQuartzCore.h>"

onekey导入所有框架的所有类别

1

"JKCategories.h" or <JKCategories/JKCategories.h>

Content

Foundation

NSArray
NSBundle
NSData
NSDate
NSDateFormatter
NSNotificationCenter
NSDictionary
NSException
NSFileManager
NSIndexPath
NSNumber
NSObject
NSSet
NSString
NSTimer
NSURL
NSUserDefaults
NSHTTPCookieStorage
NSFileHandle
NSRunLoop
NSURLRequest
NSOperation
NSInvocation
NSURLConnection
NSURLSession

UIKit

UIAlertView
UIApplication
UIBarButtonItem
UIBezierPath
UIButton
UIColor
UIFont
UIControl
UIDevice
UIImage
UIImageView
UILable
UINavigationBar
UINavigationController
UINavigationItem
UIResponder
UIScreen
UIScrollView
UISearchBar
UISplitViewController
UITableView
UITableViewCell
UITextField
UITextView
UIView
UIViewController
UIWebView
UIWindow
UIPopoverController
UICollectionView

QuartzCore

CALayer
CAMediaTimingFunction
CAAnimation
CAShapeLayer
CATransaction

CoreData

NSManagedObjectContext
NSFetchRequest
NSManagedObject
NSPersistentStoreCoordinator

CoreLocation

CLLocationManager
CLLocation

MapKit

MKMapView

Quick Start

Create a new post

1

$ hexo new "My New Post"

More info: Writing

Run server

1

$ hexo server

More info: Server

Generate static files

1

$ hexo generate

More info: Generating

Deploy to remote sites

1

$ hexo deploy

More info: Deployment