Block及__block详解

1. 普通变量

#import <Foundation/Foundation.h>

typedef void(^BLK)(void);

int main(int argc, const char * argv[]) {
    @autoreleasepool {
        BLK block1;
        {
            int a = 2;
            block1 = ^{
                a++;
            };
            block1();
        }
    }
    return 0;
}

报错：变量a缺少__block修饰
原因：
block1对应的C语言结构体中其实是有一个自己的变量int a的，这个a接收了外部a的值，就像方法内部的变量接收了参数的值，但是在Block内是无法修改外部a的值的。

普通变量.png

2. 全局静态变量

#import <Foundation/Foundation.h>

typedef void(^BLK)(void);

static int a = 2;
int main(int argc, const char * argv[]) {
    @autoreleasepool {
        BLK block1;
        {
            block1 = ^{
                a++;
                printf("a = %d\n", a);
            };
            block1();
        }
    }
    return 0;
}

结果：a = 3
原因：a是全局静态变量，在任何地方都可以使用

全局静态变量.png

3. 局部静态变量

#import <Foundation/Foundation.h>

typedef void(^BLK)(void);

int main(int argc, const char * argv[]) {
    @autoreleasepool {
        BLK block1;
        {
            static int a = 2;
            block1 = ^{
                a++;
                printf("a = %d\n", a);
            };
            block1();
        }
    }
    return 0;
}

结果：a = 3
原因：Block截获了静态变量a的指针，并将该指针传递给Block中的同名指针变量a，这样通过指针即可修改外部a的值；看图

局部静态变量传递指针.png

4. __block修饰变量

#import <Foundation/Foundation.h>

typedef void(^BLK)(void);

int main(int argc, const char * argv[]) {
    @autoreleasepool {
        BLK block1;
        {
            __block int a = 2;
            block1 = ^{
                a++;
                printf("a = %d\n", a);
            };
            block1();
        }
    }
    return 0;
}

结果：a = 3
原因：
__block修饰的变量，不再是一个普通的变量，而是被声明为一个结构体；
将外部结构体a的指针&a作为参数，传递给Block的构造函数
Block结构体内部也有一个指向变量结构体的指针a，指针a接收到了构造函数传来的参数&外部结构体变量a，所以这里跟上面局部静态变量的情况一样，是通过传递指针来实现访问Block外部的变量的；看图：

__block修饰变量.png

修改变量.png

5. 截获对象

截获对象时，有2中情况：
1、不可以修改对象

不可修改对象.png

2、可以修改对象的值

可修改对象的值.png

我们以第二种情况为例，看看C语言代码

截获对象.png

看起来和上面的普通变量的情况差不多，都是值做参数；但是为什么上面不可以修改变量，而这里可以修改对象的值，但是不能修改对象呢？？

原因：
上面普通变量的情况中，传递的是具体的值；这里传递的不是值，而是指针；
我们知道数组名就是指向数组的指针，所以我们传递的是指针，因此可以修改指针所指的内存中的内容（可以对数组进行增删改查），而不可以修改指针（如同上面普通变量情况中，不可以修改变量）

关系图.png

如果我们要修改对象，可以通过__block关键字进行

6. __block修饰对象

#import <Foundation/Foundation.h>

typedef void(^BLK)(void);

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

结果：1
原因：
(1) __block关键字使原来的mutableArray被同名结构体取代
(2) 外部结构体变量的指针作为Block构造函数的参数
(3) Block内部的结构体指针，通过构造函数接收了指向外部变量的指针
(4) &mutableArray指向结构体，所以我们可以更改结构体（代码上表现为可重新定义对象），也可以修改对象（增删）

关系图2.png

__block修饰对象.png

综上所述，

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

个人学习，可留言指正

最后编辑于：2019.05.13 15:34:33