07--应用加载05--类扩展和关联对象分析

TOC

类拓展分析

类拓展特点

在平时开发中，经常会用类扩展和分类两个来做比较，下面来看看他们两的差别在哪里

在编译时作为类的一部分编译
所以在读取的时候直接读取ro
可以添加方法和属性

类扩展的形式

单独创建一个扩展文件

image

如果这种单独创建的头文件，没有被引用（import）

这个扩展里面的内容在编译时是不会被读取到ro的

相当于是没有使用到。
在.m中创建

image

关联对象分析

objc_setAssociatedObject（756）

1. _object_set_associative_reference 源码

_object_set_associative_reference

2. _object_set_associative_reference 关键变量

AssociationsManager 关联对象的管理者
AssociationsHashMap 所有的关联表（所有对象的）
ObjectAssociationMap 我们现在要关联的对象表
ObjcAssociation(policy, new_value); 关联存储

3. _object_set_associative_reference 参数

参数一：id object: 给哪个对象添加属性，这里要给自己添加属性，用self。
参数二：void * == id key : 属性名，根据key获取关联对象的属性的值，在 objc_getAssociatedObject 中通过次 key 获得属性的值并返回。
参数三：id value : 关联的值，也就是 set 方法传入的值给属性去保存。
参数四：objc_AssociationPolicy policy : 策略，属性以什么形式保存。

例子

objc_setAssociatedObject(self,  "name", cate_name, OBJC_ASSOCIATION_RETAIN_NONATOMIC);

objc_getAssociatedObject（756）

1. _object_get_associative_reference 源码

_object_get_associative_reference

2. _object_get_associative_reference 关键变量

AssociationsManager 关联对象的管理者
AssociationsHashMap 所有的关联表（所有对象的）
ObjectAssociationMap 我们现在要关联的对象表
value = entry.value(); 取出 value
policy = entry.policy(); 取出关联策略

3. _object_get_associative_reference 参数

参数一：id object : 获取哪个对象里面的关联的属性。
参数二：void * == id key : 什么属性，与 objc_setAssociatedObject 中的 key 相对应，即通过 key 值取出 value。

例子

return objc_getAssociatedObject(self, "name");

关联对象管理类

image

1. AssociationsManager 管理类

管理所有的关联对象
通过 散列表_mapStorage 进行管理，是一个全局的静态变量
键key：对象的地址object
值value：ObjectAssociationMap散列表

class AssociationsManager {
    using Storage = ExplicitInitDenseMap<DisguisedPtr<objc_object>, ObjectAssociationMap>;
    static Storage _mapStorage;
    ……

2. ObjectAssociationMap 散列表

管理对象的关联属性
一个对象对应一个 ObjectAssociationMap散列表
键key：关联属性的key
值value：ObjcAssociation对象

typedef DenseMap<const void *, ObjcAssociation> ObjectAssociationMap;

3. ObjcAssociation 类

具体的关联对象
属性 _policy：记录关联属性的策略
属性 _value：记录关联属性的值

class ObjcAssociation {
    uintptr_t _policy;
    id _value;
    ……

_object_get_associative_reference（779）

源码版本：objc4-779.1。
相对于以前的版本，简化了一些代码

_object_get_associative_reference(id object, const void *key)
{
    ObjcAssociation association{};
    {
        AssociationsManager manager;
        AssociationsHashMap &associations(manager.get());
        AssociationsHashMap::iterator i = associations.find((objc_object *)object);
        if (i != associations.end()) {
            ObjectAssociationMap &refs = i->second;
            ObjectAssociationMap::iterator j = refs.find(key);
            if (j != refs.end()) {
                association = j->second;
                association.retainReturnedValue();
            }
        }
    }

    return association.autoreleaseReturnedValue();
}

理解了上面的内容，这里获取就显得简单得多，不看代码都能猜得到的流程：

取得全局的属性关联表存储表AssociationsHashMap
通过对象地址去获取对象的属性关联表ObjectAssociationMap；
通过属性关联key去获取属性关联对象association；
获取属性关联对象中的value，并返回autoreleaseReturnedValue；

实际上，流程就是这样的。在get的过程中会对value临时持有。

_object_set_associative_reference（779）

void
_object_set_associative_reference(id object, const void *key, id value, uintptr_t policy)
{
    DisguisedPtr<objc_object> disguised{(objc_object *)object};
    ObjcAssociation association{policy, value};

    // retain the new value (if any) outside the lock.
    association.acquireValue();
    {
        AssociationsManager manager;
        AssociationsHashMap &associations(manager.get());

        if (value) {
            auto refs_result = associations.try_emplace(disguised, ObjectAssociationMap{});
            if (refs_result.second) {
                /* it's the first association we make */
                object->setHasAssociatedObjects();
            }

            /* establish or replace the association */
            auto &refs = refs_result.first->second;
            auto result = refs.try_emplace(key, std::move(association));
            if (!result.second) {
                association.swap(result.first->second);
            }
        } else {
            auto refs_it = associations.find(disguised);
            if (refs_it != associations.end()) {
                auto &refs = refs_it->second;
                auto it = refs.find(key);
                if (it != refs.end()) {
                    association.swap(it->second);
                    refs.erase(it);
                    if (refs.size() == 0) {
                        associations.erase(refs_it);

                    }
                }
            }
        }
    }

    // release the old value (outside of the lock).
    association.releaseHeldValue();
}

可以看到在set方法中，有几个if-else分支，下面主要对这几个分支进行说明。

1. if (value) {}：判断value是否有值

如果有值，则进入正常的赋值流程
如果没有值，则会删除这个属性key所对应的关联对象

2. if (refs_result.second)：判断是否是第一次关联

如果是第一次关联，则需要设置 isa指针的关联位 setHasAssociatedObjects
如果不是，则进入下面的流程，建立或者替代 association

【解答】关联对象跟setter、getter、属性、变量，有关吗？

一毛钱的关系都没有

std::map<char, int> 使用

初始化一个map
```
std::map<char, int> mymap;
```

存储值

mymap['c'] = 100;
mymap['o'] = 200;
mymap['o'] = 300;
mymap['c'] = 400;
mymap['i'] = 500;

map的迭代器 - 迭代输出

for (std::map<char,int>::iterator it=mymap.begin(); it!=mymap.end(); ++it)
    std::cout << "输出 " << it->first << " => " << it->second << '\n';

llvm中的数据结构及内存分配策略 - DenseMap