block底层实现原理

最新推荐文章于 2022-03-28 11:35:35 发布
最新推荐文章于 2022-03-28 11:35:35 发布
阅读量2.2k 收藏
点赞数
分类专栏： iOS 文章标签： clang Objective-C block
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/oqqQuZi1234567/article/details/44070993
版权

objc含block的源代码

#include"stdio.h"
int main()
{
        void (^blk)(void) = ^{printf("Block.\n");};
    blk();
    return 0;

}

将此源代码clang变换成底层C代码：（clang-rewrite-objc main.m） 

#ifndef __OBJC2__
#define __OBJC2__
#endif
struct objc_selector; struct objc_class;
struct __rw_objc_super {
    struct objc_object *object;
    struct objc_object *superClass;
    __rw_objc_super(struct objc_object *o, struct objc_object *s) : object(o), superClass(s) {}
};
#ifndef _REWRITER_typedef_Protocol
typedef struct objc_object Protocol;
#define _REWRITER_typedef_Protocol
#endif
#define __OBJC_RW_DLLIMPORT extern
__OBJC_RW_DLLIMPORT void objc_msgSend(void);
__OBJC_RW_DLLIMPORT void objc_msgSendSuper(void);
__OBJC_RW_DLLIMPORT void objc_msgSend_stret(void);
__OBJC_RW_DLLIMPORT void objc_msgSendSuper_stret(void);
__OBJC_RW_DLLIMPORT void objc_msgSend_fpret(void);
__OBJC_RW_DLLIMPORT struct objc_class *objc_getClass(const char *);
__OBJC_RW_DLLIMPORT struct objc_class *class_getSuperclass(struct objc_class *);
__OBJC_RW_DLLIMPORT struct objc_class *objc_getMetaClass(const char *);
__OBJC_RW_DLLIMPORT void objc_exception_throw( struct objc_object *);
__OBJC_RW_DLLIMPORT int objc_sync_enter( struct objc_object *);
__OBJC_RW_DLLIMPORT int objc_sync_exit( struct objc_object *);
__OBJC_RW_DLLIMPORT Protocol *objc_getProtocol(const char *);
#ifdef _WIN64
typedef unsigned long long  _WIN_NSUInteger;
#else
typedef unsigned int _WIN_NSUInteger;
#endif
#ifndef __FASTENUMERATIONSTATE
struct __objcFastEnumerationState {
    unsigned long state;
    void **itemsPtr;
    unsigned long *mutationsPtr;
    unsigned long extra[5];
};
__OBJC_RW_DLLIMPORT void objc_enumerationMutation(struct objc_object *);
#define __FASTENUMERATIONSTATE
#endif
#ifndef __NSCONSTANTSTRINGIMPL
struct __NSConstantStringImpl {
    int *isa;
    int flags;
    char *str;
    long length;
};
#ifdef CF_EXPORT_CONSTANT_STRING
extern "C" __declspec(dllexport) int __CFConstantStringClassReference[];
#else
__OBJC_RW_DLLIMPORT int __CFConstantStringClassReference[];
#endif
#define __NSCONSTANTSTRINGIMPL
#endif
#ifndef BLOCK_IMPL
#define BLOCK_IMPL
struct __block_impl {
    void *isa;
    int Flags;
    int Reserved;
    void *FuncPtr;
};
// Runtime copy/destroy helper functions (from Block_private.h)
#ifdef __OBJC_EXPORT_BLOCKS
extern "C" __declspec(dllexport) void _Block_object_assign(void *, const void *, const int);
extern "C" __declspec(dllexport) void _Block_object_dispose(const void *, const int);
extern "C" __declspec(dllexport) void *_NSConcreteGlobalBlock[32];
extern "C" __declspec(dllexport) void *_NSConcreteStackBlock[32];
#else
__OBJC_RW_DLLIMPORT void _Block_object_assign(void *, const void *, const int);
__OBJC_RW_DLLIMPORT void _Block_object_dispose(const void *, const int);
__OBJC_RW_DLLIMPORT void *_NSConcreteGlobalBlock[32];
__OBJC_RW_DLLIMPORT void *_NSConcreteStackBlock[32];
#endif
#endif
#define __block
#define __weak

#include <stdarg.h>
struct __NSContainer_literal {
    void * *arr;
    __NSContainer_literal (unsigned int count, ...) {
        va_list marker;
        va_start(marker, count);
        arr = new void *[count];
        for (unsigned i = 0; i < count; i++)
            arr[i] = va_arg(marker, void *);
        va_end( marker );
    };
    ~__NSContainer_literal() {
        delete[] arr;
    }
};
extern "C" __declspec(dllimport) void * objc_autoreleasePoolPush(void);
extern "C" __declspec(dllimport) void objc_autoreleasePoolPop(void *);

struct __AtAutoreleasePool {
    __AtAutoreleasePool() {atautoreleasepoolobj = objc_autoreleasePoolPush();}
    ~__AtAutoreleasePool() {objc_autoreleasePoolPop(atautoreleasepoolobj);}
    void * atautoreleasepoolobj;
};

#define __OFFSETOFIVAR__(TYPE, MEMBER) ((long long) &((TYPE *)0)->MEMBER)

typedef signed char __int8_t;



typedef unsigned char __uint8_t;
typedef short __int16_t;
typedef unsigned short __uint16_t;
typedef int __int32_t;
typedef unsigned int __uint32_t;
typedef long long __int64_t;
typedef unsigned long long __uint64_t;

typedef long __darwin_intptr_t;
typedef unsigned int __darwin_natural_t;
typedef int __darwin_ct_rune_t;





typedef union {
    char __mbstate8[128];
    long long _mbstateL;
} __mbstate_t;

typedef __mbstate_t __darwin_mbstate_t;


typedef long int __darwin_ptrdiff_t;







typedef long unsigned int __darwin_size_t;





typedef __builtin_va_list __darwin_va_list;





typedef int __darwin_wchar_t;




typedef __darwin_wchar_t __darwin_rune_t;


typedef int __darwin_wint_t;




typedef unsigned long __darwin_clock_t;
typedef __uint32_t __darwin_socklen_t;
typedef long __darwin_ssize_t;
typedef long __darwin_time_t;
typedef __int64_t __darwin_blkcnt_t;
typedef __int32_t __darwin_blksize_t;
typedef __int32_t __darwin_dev_t;
typedef unsigned int __darwin_fsblkcnt_t;
typedef unsigned int __darwin_fsfilcnt_t;
typedef __uint32_t __darwin_gid_t;
typedef __uint32_t __darwin_id_t;
typedef __uint64_t __darwin_ino64_t;

typedef __darwin_ino64_t __darwin_ino_t;



typedef __darwin_natural_t __darwin_mach_port_name_t;
typedef __darwin_mach_port_name_t __darwin_mach_port_t;
typedef __uint16_t __darwin_mode_t;
typedef __int64_t __darwin_off_t;
typedef __int32_t __darwin_pid_t;
typedef __uint32_t __darwin_sigset_t;
typedef __int32_t __darwin_suseconds_t;
typedef __uint32_t __darwin_uid_t;
typedef __uint32_t __darwin_useconds_t;
typedef unsigned char __darwin_uuid_t[16];
typedef char __darwin_uuid_string_t[37];


struct __darwin_pthread_handler_rec {
    void (*__routine)(void *);
    void *__arg;
    struct __darwin_pthread_handler_rec *__next;
};

struct _opaque_pthread_attr_t {
    long __sig;
    char __opaque[56];
};

struct _opaque_pthread_cond_t {
    long __sig;
    char __opaque[40];
};

struct _opaque_pthread_condattr_t {
    long __sig;
    char __opaque[8];
};

struct _opaque_pthread_mutex_t {
    long __sig;
    char __opaque[56];
};

struct _opaque_pthread_mutexattr_t {
    long __sig;
    char __opaque[8];
};

struct _opaque_pthread_once_t {
    long __sig;
    char __opaque[8];
};

struct _opaque_pthread_rwlock_t {
    long __sig;
    char __opaque[192];
};

struct _opaque_pthread_rwlockattr_t {
    long __sig;
    char __opaque[16];
};

struct _opaque_pthread_t {
    long __sig;
    struct __darwin_pthread_handler_rec *__cleanup_stack;
    char __opaque[8176];
};

typedef struct _opaque_pthread_attr_t __darwin_pthread_attr_t;
typedef struct _opaque_pthread_cond_t __darwin_pthread_cond_t;
typedef struct _opaque_pthread_condattr_t __darwin_pthread_condattr_t;
typedef unsigned long __darwin_pthread_key_t;
typedef struct _opaque_pthread_mutex_t __darwin_pthread_mutex_t;
typedef struct _opaque_pthread_mutexattr_t __darwin_pthread_mutexattr_t;
typedef struct _opaque_pthread_once_t __darwin_pthread_once_t;
typedef struct _opaque_pthread_rwlock_t __darwin_pthread_rwlock_t;
typedef struct _opaque_pthread_rwlockattr_t __darwin_pthread_rwlockattr_t;
typedef struct _opaque_pthread_t *__darwin_pthread_t;
typedef int __darwin_nl_item;
typedef int __darwin_wctrans_t;

typedef __uint32_t __darwin_wctype_t;



typedef __darwin_va_list va_list;
typedef __darwin_size_t size_t;

extern "C" {
    
    int renameat(int, const char *, int, const char *) __attribute__((availability(macosx,introduced=10.10)));
    
}

typedef __darwin_off_t fpos_t;
struct __sbuf {
    unsigned char *_base;
    int _size;
};


struct __sFILEX;
typedef struct __sFILE {
    unsigned char *_p;
    int _r;
    int _w;
    short _flags;
    short _file;
    struct __sbuf _bf;
    int _lbfsize;
    
    
    void *_cookie;
    int (*_close)(void *);
    int (*_read) (void *, char *, int);
    fpos_t (*_seek) (void *, fpos_t, int);
    int (*_write)(void *, const char *, int);
    
    
    struct __sbuf _ub;
    struct __sFILEX *_extra;
    int _ur;
    
    
    unsigned char _ubuf[3];
    unsigned char _nbuf[1];
    
    
    struct __sbuf _lb;
    
    
    int _blksize;
    fpos_t _offset;
} FILE;

extern "C" {
    extern FILE *__stdinp;
    extern FILE *__stdoutp;
    extern FILE *__stderrp;
}
extern "C" {
    void clearerr(FILE *);
    int fclose(FILE *);
    int feof(FILE *);
    int ferror(FILE *);
    int fflush(FILE *);
    int fgetc(FILE *);
    int fgetpos(FILE * , fpos_t *);
    char *fgets(char * , int, FILE *);
    
    
    
    FILE *fopen(const char * , const char * ) __asm("_" "fopen");
    
    int fprintf(FILE * , const char * , ...) __attribute__((__format__ (__printf__, 2, 3)));
    int fputc(int, FILE *);
    int fputs(const char * , FILE * ) __asm("_" "fputs") ;
    size_t fread(void * , size_t, size_t, FILE * );
    FILE *freopen(const char * , const char * ,
                  FILE * ) __asm("_" "freopen") ;
    int fscanf(FILE * , const char * , ...) __attribute__((__format__ (__scanf__, 2, 3)));
    int fseek(FILE *, long, int);
    int fsetpos(FILE *, const fpos_t *);
    long ftell(FILE *);
    size_t fwrite(const void * , size_t, size_t, FILE * ) __asm("_" "fwrite") ;
    int getc(FILE *);
    int getchar(void);
    char *gets(char *);
    void perror(const char *);
    int printf(const char * , ...) __attribute__((__format__ (__printf__, 1, 2)));
    int putc(int, FILE *);
    int putchar(int);
    int puts(const char *);
    int remove(const char *);
    int rename (const char *, const char *);
    void rewind(FILE *);
    int scanf(const char * , ...) __attribute__((__format__ (__scanf__, 1, 2)));
    void setbuf(FILE * , char * );
    int setvbuf(FILE * , char * , int, size_t);
    int sprintf(char * , const char * , ...) __attribute__((__format__ (__printf__, 2, 3)));
    int sscanf(const char * , const char * , ...) __attribute__((__format__ (__scanf__, 2, 3)));
    FILE *tmpfile(void);
    
    
    __attribute__((deprecated("This function is provided for compatibility reasons only.  Due to security concerns inherent in the design of tmpnam(3), it is highly recommended that you use mkstemp(3) instead.")))
    
    char *tmpnam(char *);
    int ungetc(int, FILE *);
    int vfprintf(FILE * , const char * , va_list) __attribute__((__format__ (__printf__, 2, 0)));
    int vprintf(const char * , va_list) __attribute__((__format__ (__printf__, 1, 0)));
    int vsprintf(char * , const char * , va_list) __attribute__((__format__ (__printf__, 2, 0)));
}
extern "C" {
    
    
    
    char *ctermid(char *);
    
    
    
    
    
    FILE *fdopen(int, const char *) __asm("_" "fdopen");
    
    int fileno(FILE *);
}
extern "C" {
    int pclose(FILE *);
    
    
    
    FILE *popen(const char *, const char *) __asm("_" "popen");
    
}
extern "C" {
    int __srget(FILE *);
    int __svfscanf(FILE *, const char *, va_list) __attribute__((__format__ (__scanf__, 2, 0)));
    int __swbuf(int, FILE *);
}







inline __attribute__ ((__always_inline__)) int __sputc(int _c, FILE *_p) {
    if (--_p->_w >= 0 || (_p->_w >= _p->_lbfsize && (char)_c != '\n'))
        return (*_p->_p++ = _c);
    else
        return (__swbuf(_c, _p));
}
extern "C" {
    void flockfile(FILE *);
    int ftrylockfile(FILE *);
    void funlockfile(FILE *);
    int getc_unlocked(FILE *);
    int getchar_unlocked(void);
    int putc_unlocked(int, FILE *);
    int putchar_unlocked(int);
    
    
    
    int getw(FILE *);
    int putw(int, FILE *);
    
    
    
    __attribute__((deprecated("This function is provided for compatibility reasons only.  Due to security concerns inherent in the design of tempnam(3), it is highly recommended that you use mkstemp(3) instead.")))
    
    char *tempnam(const char *, const char *) __asm("_" "tempnam") ;
}
typedef __darwin_off_t off_t;

extern "C" {
    int fseeko(FILE *, off_t, int);
    off_t ftello(FILE *);
}



extern "C" {
    int snprintf(char * , size_t, const char * , ...) __attribute__((__format__ (__printf__, 3, 4)));
    int vfscanf(FILE * , const char * , va_list) __attribute__((__format__ (__scanf__, 2, 0)));
    int vscanf(const char * , va_list) __attribute__((__format__ (__scanf__, 1, 0)));
    int vsnprintf(char * , size_t, const char * , va_list) __attribute__((__format__ (__printf__, 3, 0)));
    int vsscanf(const char * , const char * , va_list) __attribute__((__format__ (__scanf__, 2, 0)));
}
typedef __darwin_ssize_t ssize_t;

extern "C" {
    int dprintf(int, const char * , ...) __attribute__((__format__ (__printf__, 2, 3))) __attribute__((availability(macosx,introduced=10.7)));
    int vdprintf(int, const char * , va_list) __attribute__((__format__ (__printf__, 2, 0))) __attribute__((availability(macosx,introduced=10.7)));
    ssize_t getdelim(char ** , size_t * , int, FILE * ) __attribute__((availability(macosx,introduced=10.7)));
    ssize_t getline(char ** , size_t * , FILE * ) __attribute__((availability(macosx,introduced=10.7)));
}







extern "C" {
    extern const int sys_nerr;
    extern const char *const sys_errlist[];
    
    int asprintf(char ** , const char * , ...) __attribute__((__format__ (__printf__, 2, 3)));
    char *ctermid_r(char *);
    char *fgetln(FILE *, size_t *);
    const char *fmtcheck(const char *, const char *);
    int fpurge(FILE *);
    void setbuffer(FILE *, char *, int);
    int setlinebuf(FILE *);
    int vasprintf(char ** , const char * , va_list) __attribute__((__format__ (__printf__, 2, 0)));
    FILE *zopen(const char *, const char *, int);
    
    
    
    
    
    FILE *funopen(const void *,
                  int (*)(void *, char *, int),
                  int (*)(void *, const char *, int),
                  fpos_t (*)(void *, fpos_t, int),
                  int (*)(void *));
}

struct __main_block_impl_0 {
    struct __block_impl impl;
    struct __main_block_desc_0* Desc;
    __main_block_impl_0(void *fp, struct __main_block_desc_0 *desc, int flags=0) {
        impl.isa = &_NSConcreteStackBlock;
        impl.Flags = flags;
        impl.FuncPtr = fp;
        Desc = desc;
    }
};
static void __main_block_func_0(struct __main_block_impl_0 *__cself) {
    printf("Block.\n");}

static struct __main_block_desc_0 {
    size_t reserved;
    size_t Block_size;
} __main_block_desc_0_DATA = { 0, sizeof(struct __main_block_impl_0)};
int main()
{
    void (*blk)(void) = (void (*)())&__main_block_impl_0((void *)__main_block_func_0, &__main_block_desc_0_DATA);
    ((void (*)(__block_impl *))((__block_impl *)blk)->FuncPtr)((__block_impl *)blk);
    return 0;
    
}
static struct IMAGE_INFO { unsigned version; unsigned flag; } _OBJC_IMAGE_INFO = { 0, 2 };
一经clang变换，原本只有8行的代码变成了500多行。
精简一下大概转换后的代码如下： 
struct __block_impl {
    void *isa;
    int Flags;
    int Reserved;
    void *FuncPtr;
};

struct __main_block_impl_0 {
    struct __block_impl impl;
    struct __main_block_desc_0* Desc;
    __main_block_impl_0(void *fp, struct __main_block_desc_0 *desc, int flags=0) {
        impl.isa = &_NSConcreteStackBlock;
        impl.Flags = flags;
        impl.FuncPtr = fp;
        Desc = desc;
    }
};
static void __main_block_func_0(struct __main_block_impl_0 *__cself) {
    printf("Block.\n");}

static struct __main_block_desc_0 {
    size_t reserved;
    size_t Block_size;
} __main_block_desc_0_DATA = { 0, sizeof(struct __main_block_impl_0)};
int main()
{
    void (*blk)(void) = (void (*)())&__main_block_impl_0((void *)__main_block_func_0, &__main_block_desc_0_DATA);
    ((void (*)(__block_impl *))((__block_impl *)blk)->FuncPtr)((__block_impl *)blk);
    return 0;
    
}
来看看转换后的main()函数： 

int main()
{
   void (*blk)(void) = (void (*)())&__main_block_impl_0((void *)__main_block_func_0, &__main_block_desc_0_DATA);
    ((void (*)(__block_impl *))((__block_impl *)blk)->FuncPtr)((__block_impl *)blk);
   return 0;
    
}

blk在这里变成了一个指针，指向结构体 __main_block_impl_0，结构体 __main_block_impl_0初始化后被取地址强制转换成函数指针--void(*)()。__block_impl是一个公共实现（学过c语言的同学都知道，__main_block_impl_0的这种写法表示其可以被类型强转为__block_impl类型）
struct __block_impl {
   void *isa;
   int Flags;
   int Reserved;
   void *FuncPtr;
};
isa指针说明block可以成为一个objc 对象。

__main_block_impl_0的意思是main函数中的第0个block的implementation（命名：所属函数名main＋block＋implementation的缩写imply＋block在所属函数中出现的顺序0），这个就是这个block的主体了。


在block中改写－静态局部变量－静态全局变量－全局变量－的值

int global_val = 1;
static int static_global_val = 2;

int main()
{
    static int static_val = 3;
    
    void (^blk)(void) = ^{
        global_val *=2;
        static_global_val *=3;
        static_val *=4;
    };
    return 0;
}
clang 变换后： 
struct __block_impl {
  void *isa;
  int Flags;
  int Reserved;
  void *FuncPtr;
};


int global_val = 1;
static int static_global_val = 2;


struct __main_block_impl_0 {
  struct __block_impl impl;
  struct __main_block_desc_0* Desc;
  int *static_val;
  __main_block_impl_0(void *fp, struct __main_block_desc_0 *desc, int *_static_val, int flags=0) : static_val(_static_val) {
    impl.isa = &_NSConcreteStackBlock;
    impl.Flags = flags;
    impl.FuncPtr = fp;
    Desc = desc;
  }
};
static void __main_block_func_0(struct __main_block_impl_0 *__cself) {
  int *static_val = __cself->static_val; // bound by copy

        global_val *=2;
        static_global_val *=3;
        (*static_val) *=4;
    }

static struct __main_block_desc_0 {
  size_t reserved;
  size_t Block_size;
} __main_block_desc_0_DATA = { 0, sizeof(struct __main_block_impl_0)};
int main()
{
    static int static_val = 3;

    void (*blk)(void) = (void (*)())&__main_block_impl_0((void *)__main_block_func_0, &__main_block_desc_0_DATA, &static_val);
    return 0;
}

加__block的变量

int main()
{
    __block int val_block = 3;
    
    void (^blk)(void) = ^{
        val_block *=4;
    };
    
    blk();
    
    return 0;
}

struct __block_impl {
  void *isa;
  int Flags;
  int Reserved;
  void *FuncPtr;
};

struct __Block_byref_val_block_0 {
  void *__isa;
__Block_byref_val_block_0 *__forwarding;
 int __flags;
 int __size;
 int val_block;
};

struct __main_block_impl_0 {
  struct __block_impl impl;
  struct __main_block_desc_0* Desc;
  __Block_byref_val_block_0 *val_block; // by ref
  __main_block_impl_0(void *fp, struct __main_block_desc_0 *desc, __Block_byref_val_block_0 *_val_block, int flags=0) : val_block(_val_block->__forwarding) {
    impl.isa = &_NSConcreteStackBlock;
    impl.Flags = flags;
    impl.FuncPtr = fp;
    Desc = desc;
  }
};
static void __main_block_func_0(struct __main_block_impl_0 *__cself) {
  __Block_byref_val_block_0 *val_block = __cself->val_block; // bound by ref

        (val_block->__forwarding->val_block) *=4;
    }
static void __main_block_copy_0(struct __main_block_impl_0*dst, struct __main_block_impl_0*src) {_Block_object_assign((void*)&dst->val_block, (void*)src->val_block, 8/*BLOCK_FIELD_IS_BYREF*/);}

static void __main_block_dispose_0(struct __main_block_impl_0*src) {_Block_object_dispose((void*)src->val_block, 8/*BLOCK_FIELD_IS_BYREF*/);}

static struct __main_block_desc_0 {
  size_t reserved;
  size_t Block_size;
  void (*copy)(struct __main_block_impl_0*, struct __main_block_impl_0*);
  void (*dispose)(struct __main_block_impl_0*);
} __main_block_desc_0_DATA = { 0, sizeof(struct __main_block_impl_0), __main_block_copy_0, __main_block_dispose_0};
int main()
{
    __attribute__((__blocks__(byref))) __Block_byref_val_block_0 val_block = {(void*)0,(__Block_byref_val_block_0 *)&val_block, 0, sizeof(__Block_byref_val_block_0), 3};

    void (*blk)(void) = (void (*)())&__main_block_impl_0((void *)__main_block_func_0, &__main_block_desc_0_DATA, (__Block_byref_val_block_0 *)&val_block, 570425344);

    ((void (*)(__block_impl *))((__block_impl *)blk)->FuncPtr)((__block_impl *)blk);

    return 0;
}

就加了个__block，代码量马上剧增。令人惊讶的是加了__block的变量变成了一个结构体__Block_byref_val_0的实例.





fnxiao
关注
专栏目录
OC底层面试知识点之 —— Block底层原理
iOS-大鑫
04-24 624
本文将介绍block的类型，循环引用的解决方法以及block底层分析 Block简介 Block定义：带有自动变量的匿名函数，它是C语言的拓展功能，之所以是扩展，是因为C语言不允许存在这样的匿名函数 匿名函数 匿名函数式指不带函数名称的函数 带有自定变量 Block拥有捕获外部变量的功能，在Block中访问一个外部的局部变量，Block会持有它的临时状态，自动捕获变量值，外部局部变量的变化不会影响它的状态（这个下面会讲到）。 Block类型 作为一个开发者，有一个学习的氛围跟一个交流圈子
block底层实现（一）
阿凡的专栏
08-13 443
首先先写一个最简单的block，代码如下 #import int main(int argc, const char * argv[]) { void(^blk)() = ^{printf("test1\n");}; blk(); } 利用clang（LLVM编译器）可以转换为我们可读源代码，通过-rewrite-objc 选项就能将代码转换
iOS中OC:block底层实现原理
whhit7447的专栏
08-22 788
Block是什么？苹果推荐的类型，效率高，在运行中保存代码。用来封装和保存代码，有点像函数，Block可以在任何时候执行。 Block和函数的相似性：（1）可以保存代码（2）有返回值（3）有形参（4）调用方式一样。 Block 底层实现 定义一个简单的block 我们再给a赋值为20，此时打印出来a 的值还是10 但当我们在第一次给a
block的底层实现（二）
阿凡的专栏
08-13 500
先看如下代码 注以下代码均为mrc环境下运行 // // main.m // Block2 // // Created by xufan on 16/8/13. // Copyright © 2016年 xufan. All rights reserved. // #import typedef void(^blk)(void); typedef void(^blk1)(voi
Block底层实现原理
decadent_的博客
11-07 226
Block int main(int argc, const char * argv[]) { @autoreleasepool { TYBlock block = ^(){ NSLog(@"hello block"); }; block(); NSLog(@"Hello, World!"); } return 0; } ...
iOS进阶 - Block底层原理
12-25
### iOS进阶 - Block底层原理 #### 一、Block的本质 **1. Block作为一个OC对象：** - **ISA指针：** Block本质上是Objective-C中的一个对象，它内部有一个`isa`指针，用于指向Block类的元类，这与普通的OC对象是...
synchronize底层实现原理
weixin_43597392的博客
03-28 2805
synchronize底层实现原理 相信对Java程序员来说，synchronized关键字对大家来说并不陌生，当我们遇到并发情况时，优先会想到用synchronized关键字去解决，synchronized确实能够帮助我们去解决并发的问题，但是它会引起一些其他问题，比如最突出的一点就是程序效率问题，不过后面随着JDK1.6对synchronized关键字做出了许多优化，让synchronized和java.util.concurrent.locks.ReentrantLock等并发包中的类效率差不多。下面
block实现原理
01-14
iOS开发，block实现原理。深入讲解block实现原理以及讲解与内存管理之间的联系。
iOS底层 - Block实现原理
hiccuptang
01-29 1131
Block的底层基本结构 void blockTest() { void (^block)(void) = ^{ NSLog(@"Hello World!"); }; block(); } int main(int argc, char * argv[]) { @autoreleasepool { blockTest(); } } 通过clang命令查看编译器是如何实现Block的，在终端输入XCRun -sdk iphone.
Block底层原理（一）
liujingran_2015的博客
12-15 710
（一）block的本质，是一个结构体 （二）捕获变量 第一种：没有参数，在block中打印，无需捕获 void (^block)(void) = ^{ NSLog(@"Hello, World!"); }; 编译成c++代码后（xcrun -sdk phones clang -arch arm64 -rewrite-objc 要编译的文...
Block 底层实现原理
集腋成裘
02-16 1413
Block 底层实现原理 在理解 Block 的底层实现原理的过程中，可以通过 clang 命令将一个 block 例子转换为 C 代码，从而解读其具体的代码实现逻辑。 clang main.m -rewrite-objc -o dest.cpp 上面的命令，是将 main.m 文件源码转换为 C 语言代码并存储在 dest.cpp 文件中。 理解 block 的实现 第一步，准备一个 mai...
OC block底层实现原理
JinManli的博客
07-23 1434
先看两个实例 1、 typedef void(^captureObjectBlock)(void); captureObjectBlock testBlock; - (void)viewDidLoad { [super viewDidLoad]; [self captureObject]; testBlock(); } - (void)captureObject {...
iOS OC语言: Block底层实现原理
weixin_30570101的博客
06-21 78
来源http://www.wtoutiao.com/p/11dgbk4.html 先来简单介绍一下Block Block是什么？ 苹果推荐的类型，效率高，在运行中保存代码。用来封装和保存代码，有点像函数，Block可以在任何时候执行。 Block和函数的相似性：（1）可以保存代码（2）有返回值（3）有形参（4）调用方式一样。 Block 底层实现 定义一个简单的block ...
Block底层实现
qianlima210210的专栏
11-26 629
//步骤一：创建一个控制台应用，在main中添加块的测试代码 #import <Foundation/Foundation.h> int main(int argc, const char * argv[]) { void (^testBlock)(void) = ^{ printf("msg log hehe"); }; test...
block的底层实现
唐枫专栏
11-08 407
1、我们都会使用 block ，但是它真正是如何工作的呢？换句话说block的本质是什么？ 看下列实例，想想程序的结果：int main(int argc, const char * argv[]) { int a = 10; __block int b = 20; void (^block)() = ^(){ printf("a = %d\n",a);
手把手讲解block底层实现原理
chuangsha3785的博客
04-21 192
前言　 　　要探索Block前先说一下我对Block的理解,我把它理解为：能够捕获它所在函数内部的变量的函数指针、匿名函数或者闭包。注意红色部份说的是它的精髓所在。希望看我这篇文章的人能够跟我说的步骤去做，做起来也比较简单，基本上是手把手，这样会有更好的效果，更深刻，当然如果只看文章就能够让...
深入理解 __block 修饰符的底层实现原理
iOS_开发
04-08 303
????????关注后回复“进群”，拉你进程序员交流群????????转自：掘金 GDCoderhttps://juejin.cn/post/6942796652717539364在...
Block底层详解
majiakun1的专栏
03-08 2843
block详解1.前言2.block的类型2.1.总共三种类型，具体如下:2.2 __ NSGlobalBlock__2、block数据结构3、block的变量捕获（capture）2.1auto变量的捕获2.2对象类型的auto变量4、block的Copy5、__weak问题解决6、__block修饰符6.1使用6.2内存管理6.3__forwarding指针7、循环引用 1.前言 本文旨在对block底层进行详细的探究，源码参考libclosure-79。 2.block的类型 2.1.总共三种类型，
Block 本质、实现原理、内存管理、循环引用、__block等
idealPC的专栏
02-21 1626
一、Block介绍 1.1概念： 将函数及其执行上下文封装起来的对象 底层用struct实现 1.2block实现原理： a .新建项目 代码放入file.m中 b.打开终端cd到项目目录下 c.敲clang -rewrite-objc file.m查看编译后的文件内容 本质是将OC重写为C后目录下多了个file.cpp文件 1）Block实际上是OC对于闭包（闭包是一个函数或指向函数的指针，再加上该函数执行的外部的上下文变量。）的实现。OC是对C语言的扩展，block的实现是基于函数和指向函数的
互斥锁的底层实现原理
最新发布
09-08
互斥锁的底层实现原理通常涉及操作系统级别的原子操作和状态管理。 互斥锁的基本工作原理如下： 1. 锁的状态：互斥锁维护一个状态来表示当前锁是未锁定（unlocked）还是锁定（locked）状态。 2. 尝试锁定：当线程...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值