Block访问外部变量

上一篇文章我们使用了一个最简单的Block的例子说明Block是一个对象，但是我们平时使用的Block大部分是带有参数的，或者是能够访问到Block外部的局部变量的，那么这种类型的Block是怎么实现的呢？
我们首先看一个访问外部局部变量的例子：

int main()
{
    int val = 10;
    const char* fmt = "val = %d\n";
    void (^blk)(void) = ^{printf(fmt, val);};

    val = 20;

    blk();

    return 0;
}

也许很多人会以为这段代码输出结果是：val = 20，其实这段代码输出结果是val = 10。
为什么呢？
因为在Block实现的时候，Block中使用的局部变量已经被“捕获”了。

何为“捕获”

我们该怎么理解“捕获”呢？我们再一次祭出上一篇的终极武器——clang，通过clang转化后的主要代码如下：

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

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 val = 10;
    const char* fmt = "val = %d\n";
    void (*blk)(void) = &__main_block_impl_0((void *)__main_block_func_0, &__main_block_desc_0_DATA, fmt, val));

    val = 20;

    blk->FuncPtr(blk);

    return 0;
}

根据上一篇讲述的内容，我们可以发现Block的实现是struct __main_block_impl_0，这个结构体比上一篇的结构体多了两个成员变量fmt和val，这两个成员变量在构造函数中就已经被赋值了。而在main函数中，这个结构体的构造函数调用时机是在val变量赋值为20之前。所以即使我们给val赋值为20了，因为__main_block_impl_0构造函数已经在赋值之前调用了，__main_block_impl_0的结构体成员变量val已经被赋值为10了，也就是说val = 20这行代码，改变的是main函数中的val局部变量的值，而不是Block对象中val变量的值。
所谓“捕获”其实质是Block体内的变量与被Block引用的外部局部变量是两个不同的变量，它们有不同的作用域，有不同的存储空间，它们的值早在Block实现时就已经确定好了，而不是在Block执行时才被确定的。
我们可以用下面的图描述一下上述代码执行时内存的变化过程：

内存变化

上面的结论我们可以通过如下代码验证：

int val = 10;
const char* fmt = "val = %d\n";
printf("address of val = 0x%lx, address of fmt = 0x%lx\n", &val, &fmt);
void (^blk1)(void) = ^{
    printf("address of val = 0x%lx, address of fmt = 0x%lx\n", &val, &fmt);
    printf(fmt, val);
};

val = 20;
    
blk1();

上述代码输出结果如下：

地址不同

从输出结果也可以看出，两个val和fmt的变量地址是不同的，说明它们是两个不同的变量。

Block捕获指针

看到上面的结论，也许有人会疑惑：为什么我在编程的时候给一个局部对象的成员变量赋值后，再调用Block，得到的是赋值后的值呢？
我们将上面的例子修改一下：

@interface BlockTest : NSObject

@property(nonatomic, assign) int num;

@end

@implementation BlockTest

@end

int main(int argc, const char * argv[]) {
    BlockTest *test = [[BlockTest alloc] init];
    test.num = 10;
    const char *fmt = "val = %d\n";
    void(^blk)(void) = ^{
      printf(fmt, test.num);
    };

    test.num = 20;
    
    blk();
    
    return 0;
}

这时候输出的结果是val = 20。这是为什么呢？
我们需要搞清楚Objective-C对象的内存管理机制。在这个例子中，虽然main函数中的test和Block里的test是不同的对象，但是它们指向的确是同一个对象的实现，因为Block里的test对象不是通过copy来赋值的，而是通过strong引用来赋值的(在非ARC环境下是assign引用，类似于ARC环境下的weak引用)，所以我们在main函数中修改了对象的属性，也会作用到Block对象里的test成员。

总结

通过本篇的讲解，我们了解到Block内部的变量与Block外部的变量实际上是不同的变量，但是因为我们平时在Block内部使用的都是对象，而Block内部对象是通过strong引用的方式来访问外部变量的，以至于掩盖了Block会捕获外部变量的特性。