美文网首页
OC语法相关

OC语法相关

作者: KeepOnline | 来源:发表于2020-08-07 14:46 被阅读0次

1.一个NSObject对象占用多少内存?

  • 系统分配了16个字节给NSObject对象(通过malloc_size函数获得)
  • 但NSObject对象内部只使用了8个字节的空间(在64bit环境下,可以ton过class_getInstanceSize函数获得

2.对象的isa指针指向哪里?

  • instance对象的isa指针指向class对象
  • class对象的isa指针指向meta-class对象
  • meta-class对象的isa指针指向基类的meta-class对象

3.OC的类信息存放在哪里?

  • 对象方法、属性、成员变量、协议信息,存放在class对象中
  • 类方法,存放在meta-class对象中
  • 成员变量的具体值,存放在instance对象

KVO

  • KVO的全称是Key-Value-Observing,俗称“键值监听”,可以用于监听某个对象属性值的改变

                    ——————监听—————— 
    Person(age)                         Observer
                    <————————————————
    

未使用KVO监听的对象

  • Person的instance对象(isa)
  • Person的class对象(isa、superclass、setAge:、age、......)
    • [Person setAge:]
    • [Person age]

使用了KVO监听的对象

  • Person的instance对象(isa)
  • NSKVONotifying_Person的class对象(isa、superclass、setAge:、class、dealloc、_isKVOA、......)
    • setAge: 内部调用 Foundation的 _NSSetIntValueAndNotify
    • class return [Person class]
  • Person的class对象(isa、superclass、setAge:、age、......)
    • [Person setAge:]
    • [Person age]
_NSSet*ValueAndNotify的内部实现
    [self willChangeValueForKey:@"age"];
    // 原来的setter实现
    [self didChangeValueForKey:@"age"];
  • 调用willChangeValueForKey:
  • 调用原来的setter实现
  • 调用didChangeValueForKey:
    • didChangeValueForKey:内部会调用observer的observeValueForKeyPath:ofObject:change:context:方法

1.iOS用什么方式实现对一个对象的KVO?(KVO的本质是什么?)

  • 利用RuntimeApi动态生成一个子类,并且让instance对象的isa指针指向这个全新的子类
  • 当修改instance对象的属性时,会调用Foundation的_NSSetXXXValueAndNotify函数
    • willChangeValueForKey:
    • 父类原来的setter
    • didChangeValueForKey:
  • 内部会触发监听器(Oberser)的监听方法(observeValueForKeyPath:ofObject:change:context:)

2.如何手动触发KVO?

手动调用willChangeValueForKey:和didChangeValueForKey:

3.直接修改成员变量会触发KVO么?

不会触发KVO

4.通过KVC修改属性会触发KVO么?

会触发KVO

KVC

  • KVC的全称是Key-Value Coding,俗称”键值编码“,可以通过一个key来访问某个属性

常见的API

    - (void)setValue:(id)value forKeyPath:(NSString *)keyPath;
    - (void)setValue:(id)value forKey:(NSString *)key;
    - (id)valueForKeyPath:(NSString *)keyPath;
    - (id)valueForKey:(NSString *)key;

setValue:forKey:的原理

  • setValue:forKey:
    • 按照setKey:、_setKey:顺序查找方法
      • 找到了方法(传递参数,调用方法)
      • 没找到方法
        • 查看accessInstanceVariablesDirectly方法的返回值
          • NO(调用setValue:forUndefinedKey并抛出异常NSUnknownKeyException
          • YES
            • 按照 _key、 _isKey、key、isKey顺序查找成员变量
              • 找到了成员变量(直接赋值)
              • 没有找到成员变量(调用setValue:forUndefinedKey:并抛出异常NSUnknownKeyException)

valueForKey:的原理

  • valueForKey:
    • 按照 getKey、key、isKey、_key顺序查找方法
      • 找到了方法(调用方法)
      • 没找到方法
        • 查看accessInstanceVariablesDirectly方法的返回值
          • NO(调用valueForUndefinedKey:并抛出异常NSUnknownKeyException)
          • YES(按照_key、isKey、key、isKey的顺序查找成员变量)
            • 找到了成员变量(直接取值)
            • 没有找到成员变量(调用valueForUndefindKey:并抛出异常NSUnknownKeyException)

Category

Category的底层结构

  • 定义在objc-runtime-new.h中
    struct category_t {
        const char * name;
        classref_t cls;
        struct method_list_t * instanceMethods;
        struct methos_list_t * classMethods;
        struct protocol_list_t * protocols;
        struct property_list_t * instanceProperties;
        struct property_list_t * _classProperties;
        
        method_list_t * methodsForMeta(bool isMeta) {
            if (isMeta) return classMethods;
            else return instanceMethods;
        }
        
        property_list_t * propertiesForMeta(bool isMeta, struct header_info * hi);
    };

Category的加载处理过程

  • 1.通过Runtime加载某个类的所有Category数据
  • 2.把所有Category方法、属性、协议数据,合并到一个大数组中
    • 后面参与编译的Category数据,会在数组的前面
  • 3.将合并后的分类数据(方法、属性、协议),插入到类原来数据的前面

源码解读顺序

objc-os.mm
        _objc_init
        map_images
        map_images_nolock
        
objc_runtime-new.mm
        _read_images
        remethodizeClass
        attachCategories
        attachLists
        realloc、memmove、memcpy

1.Category的使用场合是什么?

  • Category的实现原理
    • Category编译之后的底层结构是struct categort_t,里面存储着分类的对象方法、类方法、属性、协议信息
    • 在程序运行的时候,runtime会将Category的数据,合并到类信息中(类对象、元类对象中)
  • Category和Class Extension的区别是什么?
    • Class Extension在编译的时候,它的数据就已经包含在类信息中
    • Category是在运行时,才会将数据合并到类信息中

2.Category中有load方法吗?load方法是什么时候调用的?load方法能继承吗?

  • 有load方法
  • load方法在runtime加载类、分类的时候调用
  • load方法可以继承,但是一般情况下不会主动去调用load方法,都是让系统自动调用

3.Category能否添加成员变量?如果可以,如何给Category添加成员变量?

  • 不能直接给Category添加成员变量,但是可以间接实现Category有成员变量的效果

如何实现给分类”添加成员变量“?

  • 默认情况下,因为分类底层结构的限制,不能添加成员变量到分类中。但是可以通过关联对象来间接实现
  • 关联对象提供了以下API
    // 添加关联对象
    void objc_setAssociatedObject(id object, const void * key, id value, objc_AssociationPolicy policy)
    
    // 获得关联对象
    id objc_getAssociatedObject(id object, const void * key)
    
    // 移除所有的关联对象
    void objc_removeAssociatedObjects(id object)

key的常见用法
    static void *MyKey = &MyKey;
    objc_setAssociatedObject(obj, MyKey, value, OBJC_ASSOCIATION_RETAIN_NONATOMIC)
    objc_getAssociatedObject(obj, &MyKey)
    
    static char MyKey;
    objc_setAssociatedObject(obj, &MyKey, value, OBJC_ASSOCIATION_RETAIN_NONATOMIC)
    objc_getAssociatedObject(obj, &MyKey)
    
    // 使用属性名作为key
    objc_setAssociatedObject(obj, @"property", value, OBJC_ASSOCIATION_RETAIN_NONATOMIC)
    objc_getAssociatedObject(obj, @"property")
    
    // 使用get方法的@selector作为key
    objc_setAssociatedObject(obj, @selected(getter), value, OBJC_ASSOCIATION_RETAIN_NONATOMIC)
    objc_getAssociatedObject(obj, @selector(getter))    
    

objc_AssociationPolicy

objc_AssociationPolicy 对应的修饰符
OBJC_ASSOCIATION_ASSIGN assign
OBJC_ASSOCIATION_RETAIN_NONATOMIC strong,nonatomic
OBJC_ASSOCIATION_COPY_NONATOMIC copy,nonatomic
OBJC_ASSOCIATION_RETAIN strong, atomic
OBJC_ASSOCIATION_COPY copy, atomic

关联对象的原理

  • 实现关联对象技术的核心对象有
    • AssociationsManager
    • AssociationsHashMap
    • ObjectAssociationMap
    • ObjcAssociation

objc4源码解读:objc-references.mm

    class AssociationsManager {
        static AssociationsHashMap *_map;
    };
    
    class AssociationsHashMap : public unordered_map<disguised_ptr_t, ObjectAssociationMap>
    class ObjectAssociationMap : public std::map<void *, ObjcAssociation>
    class ObjcAssociation {
        uintptr_t _policy;
        id _value;
    };

关联对象并不是存储在被关联对象本身内存中

关联对象存储在全局的统一的一个AssociationsManager中

设置关联对象为nil,就相当于是移除关联对象

+load方法

  • +load方法会在runtime加载类、分类的时候调用
  • 每个类、分类的+load,在程序运行过程中只调用一次
  • 调用顺序
    • 1.先调用类的+load
      • 按照编译先后顺序调用(先编译,先调用)
      • 调用子类的+load之前会调用父类的+load
    • 2.在调用分类的+load
      • 按照编译先后顺序调用(先编译,先调用)

源码解读顺序

+load方法时根据方法地址直接调用,并不是经过objc_msgSend函数调用

objc-os.mm
        _objc_init
        load_images
        prepare_load_methods
            schedule_class_load
            add_class_to_loadable_list
            add_category_to_loadable_list
        call_load_methods
            call_class_loads
            call_category_loads
            (*load_method)(cls,SEL_load)

+initialize方法

  • +initialize方法会在第一次接收到消息时调用
  • 调用顺序
    • 先调用父类的+initialize方法,再调用子类的+initialize方法
    • (先初始化父类,在初始化子类,每个类只会初始化1次)
  • +initialize和+load的很大区别是,+initialize是通过objc_msgSend进行调用的,所以有一下特点
    • 如果子类没有时间+initialize,会调用父类的+initialize(所以父类的+initialize可能会被调用多次)
    • 如果分类实现了+initialize,就会覆盖本身的+initialize调用

Block

block的本质

  • block本质上也是一个OC对象,它内部也有个isa指针
  • block是封装了函数调用以及函数调用环境的OC对象
  • block的底层机构
    • Block_layout((void*)isa、(int)flags、(int)reserved、(void*(void*,...))invoke、(struct Block_descriptor *)descriptor、variables)
      • Block_descriptor((unsigned long int)reserved、(unsigned long int)size、(void*(void*,void*))copy、(void*(void*))dispose)

block变量捕获(capture)

变量类型 捕获到block内部 访问方式
局部变量 auto 值传递
局部变量 static 指针访问
全局变量 直接访问

atuo变量的捕获

    
    int age = 20;
    void (^block)(void) = ^{
        NSLog(@"age is %d", age);
    };
    
    struct __main_block_impl_0 {
        struct __block_impl impl;
        struct __main_block_desc_0 *Desc;
        int age;
    };
    
    // impl
    struct __block_impl {
        void *isa;
        int Flags;
        int Reserved;
        void *FuncPtr;
    };
    
    // Desc
    struct __main_block_desc_0 {
        size_t reserved;
        size_t Block_size;
    };

block的类型

  • block有3中类型,可以通过调用class方法或者isa指针查看具体类型,最终都是继承自NSBlock类型
    • __NSGlobalBlock__ (_NSConcreteGlobalBlock) 存放在数据区域.data区
    • __NSMallocBlock__(_NSConcreteMallocBlock) 堆
    • __NSStackBlock__ (_NSConcreteStackBlock) 栈
block类型 环境
__NSGlobalBlock__ 没有访问auto变量
__NSStackBlock__ 访问了auto变量
__NSMallocBlock__ __NSStackBlock__调用了copy
  • 每一种类型的block调用copy后的结果
Block的类 副本源的配置存储域 复制效果
_NSConcreteStackBlock 从栈复制到堆
_NSConcreteGlobalBlock 程序的数据区域 什么也不做
_NSConcreteMallocBlock 引用计数增加

block的copy

  • 在ARC环境下,编译器会根据情况自动将栈上的block赋值到堆上,比如以下情况

    • block作为函数的返回值时
    • 将block赋值给__strong指针时
    • block作为Cocoa API中方法名含有usingBlock的方法参数时
    • block作为GCD API的方法参数时
  • MRC下block属性的建议写法

    • @property(copy, nonatomic) void(^block)(void);
  • ARC下block属性的建议写法

    • @property(strong, nonatomic) void(^block)(void);
    • @property(copy, nonatomic) void (^block)(void);

对象类型的auto变量

  • 当block内部访问了对象类型的auto变量时
    • 如果block是在栈上,将不会对auto变量产生强引用

    • 如果block被拷贝到堆上

      • 会调用block内部的copy函数
      • copy函数内部会调用_Block_object_assign函数
      • _Block_object_assign函数会根据auto变量的修饰符(__strong、__weak、__unsafe_unretained)做出相对应的操作,形成强引用(retain)或者弱引用
    • 如果block从堆上移除

      • 会调用block内部的dispose函数
      • dispose函数内部会调用_Block_object_dispose函数
      • _Block_object_dispose函数会自动释放引用的auto变量(release)

1.block的原理是怎样的?本质是什么?

封装了函数调用以及调用环境的OC对象

2.block的属性修饰词为什么是copy?使用block有哪些使用注意?

  • block一旦没有进行copy操作,就不会在堆上
  • 使用注意:循环引用问题
函数 调用时机
copy函数 栈上的Block赋值到堆时
dispose函数 堆上的Block被废弃时

__weak问题解决

  • 在使用clang转换OC为C++代码时,可能会遇到一下问题
    • cannot create __weak reference in file using manual reference
  • 解决方案:支持ARC、指定运行时系统版本,比如
    • xcrun -sdk iphones clang -arch arm64 -rewrite-objc -fobjc-arc -fobjc-runtime=ios-8.0.0 main.m

__block修饰符

  • __block可以用来解决block内部无法修改auto变量值得问题
  • __block不能修饰全局变量、静态变量(static)
  • 编译器会将__block变量包装成一个对象
    • __isa__forwarding(指向自身的指针)、__flags__size、val(使用值)
    __block int age = 10;
    ^{
        NSLog(@"%d", age);
    }();
    
    struct __main_block_impl_0 {
        struct __block_impl impl;
        struct __main_block_desc_0 * Desc;
        __Block_byref_age_0 * age; // by ref
    };
    
    struct __Block_byref_age_0 {
        void *__isa;
        __Block_byref_age_0 * __forwarding;
        int __flags;
        int __size;
        int age;
    };
    

__block的内存管理

  • 当block在栈上时,并不会对__block变量产生强引用

  • 当block被copy到堆上时

    • 会调用block内部的copy函数
    • copy函数内部会调用_Block_object_assign函数
    • _Block_object_assign函数会对__block变量形成强引用(retain)
  • 当block从堆上移除时

    • 会调用block内部的dispose函数
    • dispose函数内部会调用_Block_object_dispose函数
    • _Block_object_dispose函数会自动释放引用的__block变量(release)

__block的__forwarding指针

  • 栈 (__block变量用结构体、__forwarding指向自己本身的指针)
    • 复制到堆之后(栈上的__forwarding指向复制到堆上的__block变量用结构体,堆上的__forwarding指向自己本身的指针)

对象类型的auto变量、__block变量

  • 当block在栈上时,对它们都不会产生强引用

  • 当block拷贝到堆上时,都会通过copy函数来处理它们

    • __block变量(假设变量名叫做a)
      • _Block_object_assign((void*)&dst->a,(void*)src->a,8/*BLOCK_FIELD_IS_BYREF*/);
    • 对象类型的auto变量(假设变量名叫做p)
      • _Block_object_assign((void*)&dst->p,(void*)src->p,3/*BLOCK_FIELD_IS_OBJECT*/);
  • 当block从堆上移除时,都会通过dispose函数来释放它们

    • __block变量(假设变量名叫做a)
      • _Block_object_dispose((void*)&dst->a, 8/*BLOCK_FIELD_IS_BYREF*/);
    • 对象类型的auto变量(假设变量名叫做p)
      • _Block_object_dispose((void*)&dst->,3/*BLOCK_FIELD_IS_OBJECT*/);
对象 BLOCK_FIELD_IS_OBJECT
__block变量 BLOCK_FIELD_IS_BYREF

循环引用问题

对象(self)持有Block,Block持有对象(self)

解决循环引用问题 - ARC

  • 用__weak、__unsafe_unretained解决
    __weak typeof(self) weakSelf = self;
    self.block = ^{
        printf("%p", weakSelf);
    };
    
    __unsafe_unretained id weakSelf = self;
    self.block = ^{
        NSLog(@"%p", weakSelf);
    };

对象(self)持有Block,Block对对象的持有是弱引用

  • 用__block解决(必须要调用block)
    __block id weakSelf = self;
    self.block = ^{
        printf("%p", weakSelf);
        weakSelf = nil; // (关键:设置为nil,将闭合的环切断)
    };
    self.block();

解决循环引用问题 - MRC

  • 用__unsafe_unretained解决
    __unsafe_unretained id weakSelf = self;
    self.block = ^{
        NSLog(@"%p",weakSelf);
    };
  • 用__block解决
    __block id weakSelf = self;
    self.block = ^{
        printf("%p", weakSelf);
    };

Objective-C的本质

  • 我们平时编写的Objective-C代码,底层实现其实都是C\C++
    • Objective-c ——> C\C++ ——> 汇编语言 ——> 机器语言
  • 所以Objective-C的面向对象都是基于C\C++的数据结构实现的
思考:Objective-C的对象、类主要是基于C\C++的什么数据结构实现的?
  • 结构体
  • 将Objective-C代码转换为C\C++代码
    • xcrun -sdk iphones clang -arch arm64 -rewrite-objc OC源文件 -o 输出的CPP文件
    • 如果需要链接其他框架,使用-framework参数。比如-framework UIKit

OC对象的本质

思考:一个OC对象在内存中是如何布局的?
NSObject的底层实现

@interface NSObject {
    Class isa;
}
@end

struce NSObject_IMPL {
    Class isa;
};

typedef struct objc_class *Class;

NSObject *obj = [[NSObject class] init];



@interface Student : NSObject {
    @public
    int _no;
    int _age;
}
@end

struct Student_IMPL {
    Class isa;
    int _no;
    int _age;
};

Student *stu = [[Student alloc] init];
stu->_no = 4;
stu->_age = 5;

struct Student_IMPL *stu2 = (__bridge struct Student_IMPL *)stu;
NSLog(@"%d, %d", stu2->_no, stu2->age);


@interface Student : NSOjbect {
    @public
    int _no;
    int _age;
}
@end

struct Student_IMPL {
    struct NSObject_IMPL NSObject_IVARS;
    int _no;
    int _age;
};

struct NSObject_IMPL {
    Class isa;
};


思考:一个Person对象、一个Student对象占用多少内存空间?


@interface Person : NSObject {
    int _age;
}
@end

struct Person_IMPL {
    struct NSObject_IMPL NSObject_IVARS;
    int _age
};

struct NSObject_IMPL {
    Class isa;
};


@interface Student : Person {
    int _no;
}
@end

struct Student_IMPL {
    struct Person_IMPL Person_IVARS;
    int _no;
};


实时查看内存数据

  • Debug ——> Debug Workfllow ——> View Memory (Shift + Command + M)

2个容易混淆的函数

创建一个实例对象,至少需要多少内存


#import <objc/runtime.h>
class_getInstanceSize([NSObject class]);

创建一个实例对象,实际上分配了多少内存?

#import <malloc/malloc.h>
malloc_size((__bridge const void *)obj);

OC对象的分类

Objective-C中的对象,简称OC对象,主要可以分为3种

  • instance对象(实例对象)
  • class对象(类对象)
  • meta-class(元类对象)

instance

  • instance对象就是通过alloc出来的对象,每次调用alloc都会产生新的instance对象
    NSObject *object1 = [[NSObject alloc] init];
    NSObject *object2 = [[NSObject alloc] init];
  • object1、object2是NSBbject的instance对象(实例对象)
  • 它们是不同的两个对象,分别占据着两块不同的内存
  • instance对象在内存中存储的信息包括
    • isa指针
    • 其他成员变量

class


    NSObject *object1 = [[NSObject alloc] init];
    NSObject *object2 = [[NSObject alloc] init];
    Class objectClass1 = [object1 class];
    Class objectClass2 = [object2 class];
    Class objectClass3 = [NSObject class];
    Class objectClass4 = object_getClass(object1); // Runtime API
    Class objectClass5 = object_getClass(object2); // Runtime API

  • objectClass1 ~ objectClass5都是NSObject的class对象(类对象)
  • 它们是同一个对象。每个类在内存中有且只有一个class对象
  • class对象在内存中存储的信息主要包括
    • isa指针
    • superclass指针
    • 类的属性信息(@property)、类的对象方法信息(instance method)
    • 类的协议信息(protocol)、类的成员变量信息(ivar)
    • ......

meta-class

    Class objectMetaClass = object_getClass([NSObject class]); // Runtime API
  • objectMetaClass是NSObject的meta-class对象(元类对象)
  • 每个类在内存中有且只有一个meta-class对象
  • meta-class对象和class对象的内存结构是一样的,但是用途不一样,在内存中存储的信息主要包括
    • isa指针
    • superclass指针
    • 类的类方法信息(class method)
    • ......

注意

  • 以下代码获取的objectClass是class对象,并不是meta-class对象
    Class objectClass = [[NSObject class] class];

查看Class是否为meta-class

    
    BOOL result = class_isMetaClass([NSObject class]);

isa指针

  • instance的isa指向class
    • 当调用对象方法时,通过instance的isa找到class,最后找到对象方法的实现进行调用
  • class的isa指向meta-class
    • 当调用类方法时,通过class的isa找到meta-class,最后找到类方法的实现进行调用
  • instace(isa、其他成员变量)
    • instance的isa ————> class
  • class(isa、superclass、属性、对象方法、协议、成员变量.....)
    • class的isa ——————> meta-class
  • meta-class(isa、superclass、类方法......)

instance(isa、其他成员便来那个)& ISA_MASK 找到 class(isa、superclass、属性、对象方法、协议、成员变量......) & ISA_MASK 找到 meta-class(isa、superclass、类方法......)

从64bit开始,isa需要进行一次位运算,才能计算出真实地址

    # if __arm64__
    #       define ISA_MASK             0x0000000ffffffff8ULL
    # elif __x86_64__
    #       define ISA_MASK             0x00007ffffffffff8ULL
    # endif

class、meta-class对象的本质结构都是 struct objc_class

struct objc_class的结构

    
    struct objc_class {
        Class isa;
        Class superclass;
        cache_t cache;  // 方法缓存
        class_data_bits_t bits; // 用于获取具体的类信息
    };
    
    // bits & FAST_DATA_MASK 找到 class_rw_t结构体
    
    struct class_rw_t {
        uint32_t flags;
        uint32_t version;
        const class_ro_t *ro;
        method_list_t * methods; // 方法列表
        property_list_t * properties; // 属性列表
        const protocol_list_t * protocols; // 协议列表
        Class firstSubclass;
        Class nextSiblingClass;
        char * demangledName;
    };
    
    struct class_ro_t {
        uint32_t flags;
        uint32_t instanceStart;
        uint32_t instanceSize; // instance对象占用的内存空间
    #ifdef __LP64__
        uint32_t reserved;
    #endif
        const uint8_t * ivarLayout;
        const char * name; // 类名
        method_list_t * baseMethodList;
        protocol_list_t * baseProtocols;
        const ivar_list_t * ivars; // 成员变量列表
        const uint8_t * weakIvarLayout;
        property_list_t * baseProperties;
    };

class对象的superclass指针


@interface Student : Person
@interface Person : NSObject

  • Student的class(isa、superclass、属性、对象方法、协议、成员变量......)
    • Student的superclass指针 ——————> Person的class
  • Person的class(isa、superclass、属性、对象方法、协议、成员变量......)
    • Person的superclass指针 ————————> NSObject的class
  • NSObject的class(isa、superclass、属性、对象方法、协议、成员变量......)

Student的instance对象调用Person的对象方法时,会先通过isa找到Student的class,然后通过superclass找到Person的class,最后找到对象方法的实现进行调用

meta-class对象的superclass指针

    @interface Student : Person
    @interface Person : NSObject
  • Student的meta-class(isa、superclass、类方法......)
    • Student的superclass指针 ————————> Person的meta-class
  • Person的meta-class(isa、superclass、类方法......)
    • Person的superclass指针 ————————> NSObject的meta-class
  • NSObject的meta-class(isa、superclass、类方法......)

Student的class要调用Person的类方法时,会先通过isa找到Student的meta-class,然后通过superclass找到Person的meta-class,最后找到类方法的实现进行调用

isa、superclass总结

  • instance的isa指向class
  • class的isa指向meta-class
  • meta-class的isa指向基类的meta-class
  • class的superclass指向父类的class
    • 如果没有父类,superclass指针为nil
  • meta-class的superclass指向父类的meta-class
    • 基类的meta-class的superclass指向基类的class
  • instance调用对象方法的轨迹
    • isa找到class,方法不存在,就通过superclass找父类
  • class调用类方法的轨迹
    • isa找到meta-class,方法不存在,就通过superclass找父类

相关文章

  • OC语法相关

    1.一个NSObject对象占用多少内存? 系统分配了16个字节给NSObject对象(通过malloc_size...

  • JavaScript学习笔记2—函数

    JavaScript的相关语法知识:1、函数(important)基本上所有的高级语言(C、OC、JavaScri...

  • IOS暑假小学期实训 第1天 总结 “ OC基本语法”&&“

    2016/07/09 OC基本语法 // // main.m // OC基本语法 // // Created by...

  • 代码

    1.oc基本语法 // // main.m // oc基本语法 // // Created by lanou on...

  • Cycript使用及高级用法

    Cycript支持OC,C++,Java语法,笔者直接使用Monkey集成(自带的),可以找到monkey中相关的...

  • 杂记

    OC语法问题 OC语法细节:不允许直接修改OC对象的结构体属性的成员 比如:self.scrollView.con...

  • oc基本语法

    // oc基本语法 // 整形 NSInteger a = 10; // NSLog是oc里面的...

  • 在Objective-C代码里面使用C++代码

    OC文件,不认识C++语法,只认识OC语法和C语法,使用了C++语法编译会报错 解决:后缀名改为.mm,例如把ma...

  • 无标题文章

    OC基础语法 //整型 NSIntegera =10; //NSLog是OC里面的打印函数 NSLog(@"a =...

  • OC之01基础之基础语法

    01 语法概述 不妨将OC说成是面向对象的C语言,因为OC是在C语言的基础是建立的,而且在OC的语法中是完全...

网友评论

      本文标题:OC语法相关

      本文链接:https://www.haomeiwen.com/subject/tjmfdktx.html