问题：什么是Block，Block的本质是什么？

2020-05-08 本文已影响0人姜小舟

block本质上也是一个OC对象，它内部也有个isa指针
block是封装了函数调用以及函数调用环境的OC对象
block是封装函数及其上下文的OC对象

使用 clang 将 OC 代码转换为 C++ 文件查看 block 的方法：
在命令行输入代码 clang -rewrite-objc 需要编译的OC文件.m
这时查看当前的文件夹里多了一个相同的名称的 .cpp 文件，在命令行输入 open main.cpp 查看文件：

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;
  // 构造函数（类似于OC的init方法），返回结构体对象
  __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;
  }
};

// 封装了block执行逻辑的函数
static void __main_block_func_0(struct __main_block_impl_0 *__cself) {

            NSLog((NSString *)&__NSConstantStringImpl__var_folders_2r__m13fp2x2n9dvlr8d68yry500000gn_T_main_c60393_mi_0);
        }

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(int argc, const char * argv[]) {
    /* @autoreleasepool */ { __AtAutoreleasePool __autoreleasepool;
        // 定义block变量
        void (*block)(void) = &__main_block_impl_0(
                                                   __main_block_func_0,
                                                   &__main_block_desc_0_DATA
                                                   );

        // 执行block内部的代码
        block->FuncPtr(block);
    }
    return 0;
}

Block分析

一、Block定义和使用

无参数无返回值

void (^ MyBlockOne)(void) = ^(void){
    NSLog(@"无参数，无返回值");  
};  
MyBlockOne();//block的调用

有参数无返回值

void(^MyblockTwo)(int a) = ^(int a){
    NSLog(@"@ = %d我就是block，有参数，无返回值",a);
};  
MyblockTwo(100);

有参数有返回值

int(^MyBlockThree)(int,int) = ^(int a,int b){    
    NSLog(@"%d我就是block，有参数，有返回值",a + b);
    return a + b; 
};  
MyBlockThree(12,56);

无参数有返回值

int(^MyblockFour)(void) = ^{
    NSLog(@"无参数，有返回值");
    return45;
  };
MyblockFour();

Block定义声明使用

//声明
typedef void (^Block)();
typedef int (^MyBlock)(int , int);
typedef void(^ConfirmBlock)(BOOL isOK);
typedef void(^AlertBlock)(NSInteger alertTag);

//定义属性
@property (nonatomic,copy) MyBlock myBlockOne;

//使用
self.myBlockOne = ^int (int ,int){
    //TODO
}

二、Block修改外界变量

普通变量。

#import <Foundation/Foundation.h>

typedef void(^ MyBlock)(void);

int main(int argc, const char * argv[]) {
    @autoreleasepool {
        int a = 2;
        MyBlock block = ^{
          a ++;
        };
       block1();
    }
    return 0;
}
#报错：变量a缺少__block修饰

Block对应的C语言结构体中其实是有一个自己的变量int a的，这个a接收了外部a的值，就像方法内部的变量接收了参数的值，但是在Block内是无法修改外部a的值的。clang结果如下图:

普通变量clang结果

全局静态变量

#import <Foundation/Foundation.h>

typedef void(^ MyBlock)(void);
static int a = 2;

int main(int argc, const char * argv[]) {
    @autoreleasepool {
        MyBlock block = ^{
          a ++;
          printf("a = %d\n", a);
        };
        block();
    }
    return 0;
}
#输出为：a = 3

int a为全局静态变量，在任何地方都可以使用。clang结果如下图:

全局静态变量clang结果

局部静态变量

#import <Foundation/Foundation.h>

typedef void(^ MyBlock)(void);

int main(int argc, const char * argv[]) {
    @autoreleasepool {
        static int a = 2;
        MyBlock block = ^{
          a++;
          printf("a = %d\n", a);
        };
        block();
    }
    return 0;
}
#输出为：a = 3

Block截获了静态变量a的指针，并将该指针传递给Block中的同名指针变量a，这样通过指针即可修改外部a的值。clang结果如下图:

局部静态变量clang结果

__block 修饰的外部变量。

c
MyBlock block = ^{
    NSLog(@"a = %d", a);
};
a = 3;
block();
#输出为：
#a = 3

或：

#import <Foundation/Foundation.h>

typedef void(^ MyBlock)(void);

int main(int argc, const char * argv[]) {
    @autoreleasepool {
        __block int a = 2;
        MyBlock block = ^{
          a++;
          printf("a = %d\n", a);
        };
       block();
    }
    return 0;
}
#结果：a = 3

对于用 __block 修饰的外部变量引用，block 是复制其引用地址来实现访问的。block可以修改__block 修饰的外部变量的值。
__block修饰的变量，不再是一个普通的变量，而是被声明为一个结构体。将外部结构体a的指针&a作为参数，传递给Block的构造函数。Block结构体内部也有一个指向变量结构体的指针a，指针a接收到了构造函数传来的参数&外部结构体变量a，所以这里跟上面局部静态变量的情况一样，是通过传递指针来实现访问Block外部的变量的。clang结果如下图:

__block 修饰的外部变量clang结果

截获对象。

1.不用__block修饰对象

#import <Foundation/Foundation.h>

typedef void(^ MyBlock)(void);

int main(int argc, const char * argv[]) {
    @autoreleasepool {
        NSMutableArray *mutableArray = [NSMutableArray array];
        MyBlock block1 = ^{
          mutableArray = [NSMutableArray array];
        };
       block();
    }
    return 0;
}
#报错：mutableArray对象缺少__block修饰。mutableArray对象不可被重定义。

#import <Foundation/Foundation.h>

typedef void(^ MyBlock)(void);

int main(int argc, const char * argv[]) {
    @autoreleasepool {
        NSMutableArray *mutableArray = [NSMutableArray array];
        MyBlock block1 = ^{
          mutableArray = [NSMutableArray addObject:@(1), nil];
        };
       block();
    }
    return 0;
}
#不报错：mutableArray对象不可被重定义，但mutableArray对象的值可以被修改。

之前#普通变量#的情况中，传递的是具体的值；这里传递的不是值，而是指针；
我们知道数组名就是指向数组的指针，所以我们传递的是指针，因此可以修改指针所指的内存中的内容（可以对数组进行增删改查），而不可以修改指针（如同之前#普通变量#情况中，不可以修改变量）。clang结果如下图:

不用__block修饰对象clang结果

2.用__block修饰对象

#import <Foundation/Foundation.h>

typedef void(^ MyBlock)(void);

int main(int argc, const char * argv[]) {
    @autoreleasepool {
        __block NSMutableArray *mutableArray = [NSMutableArray array];
        MyBlock block1 = ^{
          mutableArray = [NSMutableArray arrayWithObjects:@(1), nil];
          printf("%d\n", [mutableArray[0] intValue]);
        };
       block();
    }
    return 0;
}

__block关键字使原来的mutableArray被同名结构体取代；外部结构体变量的指针作为Block构造函数的参数；Block内部的结构体指针，通过构造函数接收了指向外部变量的指针；&mutableArray指向结构体，所以我们可以更改结构体（即mutableArray可重新定义对象，也可以修改对象（增删）。clang结果如下图:

__block修饰对象clang结果

综上所述：

要想在Block内修改外部变量，需要将变量的地址传进来（如采用局部静态变量的方法），或者使用__block关键字
要想在Block内重新定义外部对象，需要将对象的地址传进来（必须使用__block关键字），否则只能修改对象（增删）

问题：什么是Block，Block的本质是什么？

一、Block定义和使用

无参数无返回值

有参数无返回值

有参数有返回值

无参数有返回值

Block定义声明使用

二、Block修改外界变量

普通变量。

全局静态变量

局部静态变量

__block 修饰的外部变量。

截获对象。

综上所述：

要想在Block内修改外部变量，需要将变量的地址传进来（如采用局部静态变量的方法），或者使用__block关键字

要想在Block内重新定义外部对象，需要将对象的地址传进来（必须使用__block关键字），否则只能修改对象（增删）

猜你喜欢

热点阅读