在 《iOS面試題集錦（附答案）》 中有這樣一道題目：
在block內(nèi)如何修改block外部變量？（38題）答案如下：
38. 在block內(nèi)如何修改block外部變量？
注：本題代碼請在倉庫中查看以 Demo38 開頭的工程（公眾號請點擊原文查看 GitHub 倉庫）
先描述下問題：
默認情況下，在block中訪問的外部變量是復制過去的，即：寫操作不對原變量生效。但是你可以加上 __block 來讓其寫操作生效，示例代碼如下:
__block int a = 0;
void (^foo)(void) = ^{
a = 1;
};
foo();
//這里，a的值被修改為1
這是網(wǎng)上常見的描述。你同樣可以在面試中這樣回答，但你并沒有答到“點子上”。真正的原因，并沒有這么“神奇”，而且這種說法也有點牽強。面試官肯定會追問“為什么寫操作就生效了？” 實際上需要有幾個必要條件：
- "將 auto 從棧 copy 到堆"
- “將 auto 變量封裝為結(jié)構(gòu)體(對象)”
我會將本問題分下面幾個部分，分別作答：
- 該問題研究的是哪種
block類型? - 在
block內(nèi)為什么不能修改block外部變量 - 最優(yōu)解及原理解析
- 其他幾種解法
- 改外部變量必要條件之"將 auto 從棧 copy 到堆"
- 改外部變量必要條件之“將 auto 變量封裝為結(jié)構(gòu)體(對象)”
該問題研究的是哪種 block 類型?
今天我們討論是 __NSMallocBlock__ (或者叫 _NSConcreteMallocBlock，兩者是叫法不同，指的是同一個東西)。
| Block 類型 | 環(huán)境 |
|---|---|
__NSGlobalBlock__ |
沒有訪問 auto 變量 |
__NSStackBlock__ |
訪問了 auto 變量 |
__NSMallocBlock__ |
__NSStackBlock__ 調(diào)用了 copy |
每一種類型的 block 調(diào)用 copy 后的結(jié)果如下所示
| Block 的類 | 副本源的配置存儲域 | 復制效果 |
|---|---|---|
_NSConcreteGlobalBlock |
程序的數(shù)據(jù)區(qū)域 | 什么也不做 |
_NSConcreteStackBlock |
棧 | 從棧復制到堆 |
_NSConcreteMallocBlock |
堆 | 引用計數(shù)增加 |
在 ARC 環(huán)境下，編譯器會根據(jù)情況自動將棧上的 block 復制到堆上，比如以下情況：
- block 作為函數(shù)返回值時
- 將 block 賦值給 __strong 指針時
- block 作為 Cocoa API 中方法名含有 using Block 的方法參數(shù)時
- Block 作為 GCD APIE 的方法參數(shù)時
更多細節(jié)可以查看：
在 block 內(nèi)為什么不能修改 block 外部變量
為了保證 block 內(nèi)部能夠正常訪問外部的變量，block 有一個變量捕獲機制。
首先分析一下為什么不能修改：
Block不允許修改外部變量的值。Apple這樣設計，應該是考慮到了block的特殊性，block 本質(zhì)上是一個對象，block 的花括號區(qū)域是對象內(nèi)部的一個函數(shù)，變量進入 花括號，實際就是已經(jīng)進入了另一個函數(shù)區(qū)域---改變了作用域。在幾個作用域之間進行切換時，如果不加上這樣的限制，變量的可維護性將大大降低。又比如我想在block內(nèi)聲明了一個與外部同名的變量，此時是允許呢還是不允許呢？只有加上了這樣的限制，這樣的情景才能實現(xiàn)。
所以 Apple 在編譯器層面做了限制，如果在 block 內(nèi)部試圖修改 auto 變量（無修飾符），那么直接編譯報錯。
你可以把編譯器的這種行為理解為：對 block 內(nèi)部捕獲到的 auto 變量設置為只讀屬性---不允許直接修改。
從代碼層面進行證明：
寫一段 block 代碼：
//
// main.m
// Demo_38_block_edit_var
//
// Created by chenyilong on 2020/6/3.
// Copyright ? 2020 ChenYilong. All rights reserved.
//
#import <UIKit/UIKit.h>
#import "AppDelegate.h"
typedef void (^CYLBlock)(void);
int main(int argc, char * argv[]) {
NSString * appDelegateClassName;
@autoreleasepool {
appDelegateClassName = NSStringFromClass([AppDelegate class]);
int age = 10;
CYLBlock block = ^{
NSLog(@"age is %@", @(age));
};
block();
}
return UIApplicationMain(argc, argv, nil, appDelegateClassName);
}
使用如下命令來查看對應的 C++ 代碼：
xcrun -sdk iphoneos clang -arch arm64 -rewrite-objc main.m
代碼如下所示：
typedef void (*CYLBlock)(void);
struct __main_block_impl_0 {
struct __block_impl impl;
struct __main_block_desc_0* Desc;
int age;
__main_block_impl_0(void *fp, struct __main_block_desc_0 *desc, int _age, int flags=0) : age(_age) {
impl.isa = &_NSConcreteStackBlock;
impl.Flags = flags;
impl.FuncPtr = fp;
Desc = desc;
}
};
static void __main_block_func_0(struct __main_block_impl_0 *__cself) {
int age = __cself->age; // bound by copy
NSLog((NSString *)&__NSConstantStringImpl__var_folders_2w_wgnctp1932z76770l8lrrrbm0000gn_T_main_0d7ffa_mi_0, ((NSNumber *(*)(Class, SEL, int))(void *)objc_msgSend)(objc_getClass("NSNumber"), sel_registerName("numberWithInt:"), (int)(age)));
}
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, char * argv[]) {
NSString * appDelegateClassName;
/* @autoreleasepool */ { __AtAutoreleasePool __autoreleasepool;
appDelegateClassName = NSStringFromClass(((Class (*)(id, SEL))(void *)objc_msgSend)((id)objc_getClass("AppDelegate"), sel_registerName("class")));
int age = 10;
CYLBlock block = ((void (*)())&__main_block_impl_0((void *)__main_block_func_0, &__main_block_desc_0_DATA, age));
((void (*)(__block_impl *))((__block_impl *)block)->FuncPtr)((__block_impl *)block);
}
return UIApplicationMain(argc, argv, __null, appDelegateClassName);
}
static struct IMAGE_INFO { unsigned version; unsigned flag; } _OBJC_IMAGE_INFO = { 0, 2 };
最優(yōu)解及原理解析
說最優(yōu)解前，先來說一下
其他幾種解法
- 加 static (放在靜態(tài)存儲區(qū)/全局初始化區(qū) ) 缺點是會永久存儲，內(nèi)存開銷大。
- 將變量設置為全局變量，缺點也是內(nèi)存開銷大。
將變量設置為全局變量
原理是 block 內(nèi)外可直接訪問全局變量
加 static (放在靜態(tài)存儲區(qū)/全局初始化區(qū))
原理是 block 內(nèi)部對外部auto變量進行指針捕獲
下面介紹下最優(yōu)解
- 使用
__block關(guān)鍵字
改外部變量必要條件之"將 auto 從棧 copy 到堆"
之所以要放堆里，原因是棧中內(nèi)存管理是由系統(tǒng)管理，出了作用域就會被回收， 堆中才是可以由我們程序員管理。
這里先說結(jié)論：
在 ARC 中無論是否添加
__block，block 中的 auto 變量都會被從棧上 copy 到堆上。
下面證明下該結(jié)論：
先認識一下 __block 修飾符：
-
__block可以用于解決 block 內(nèi)部無法修改 auto 變量值的問題 -
__block不能修飾全局變量、靜態(tài)、變量（static)
編譯器會將 __block 變量包裝成一個對象
//
// main.m
// Demo_38_block_edit_var
//
// Created by chenyilong on 2020/6/3.
// Copyright ? 2020 ChenYilong. All rights reserved.
//
#import <UIKit/UIKit.h>
#import "AppDelegate.h"
typedef void (^CYLBlock)(void);
int main(int argc, char * argv[]) {
NSString * appDelegateClassName;
@autoreleasepool {
appDelegateClassName = NSStringFromClass([AppDelegate class]);
__block int age = 10;//__block 可替換為 __block auto (auto 可省略)
CYLBlock block = ^{
age = 20;
NSLog(@"age is %@", @(age));
};
block();
}
return UIApplicationMain(argc, argv, nil, appDelegateClassName);
}
下面用代碼證明下外部變量被 copy 到堆上：
我們可以打印下內(nèi)存地址來進行驗證：
__block int a = 0;
NSLog(@"定義前：%p", &a); //棧區(qū)
void (^foo)(void) = ^{
a = 1;
NSLog(@"block內(nèi)部：%p", &a); //堆區(qū)
};
NSLog(@"定義后：%p", &a); //堆區(qū)
foo();
2016-05-17 02:03:33.559 LeanCloudChatKit-iOS[1505:713679] 定義前：0x16fda86f8
2016-05-17 02:03:33.559 LeanCloudChatKit-iOS[1505:713679] 定義后：0x155b22fc8
2016-05-17 02:03:33.559 LeanCloudChatKit-iOS[1505:713679] block內(nèi)部： 0x155b22fc8
“定義后”和“block內(nèi)部”兩者的內(nèi)存地址是一樣的，我們都知道 block 內(nèi)部的變量會被 copy 到堆區(qū)，“block內(nèi)部”打印的是堆地址，因而也就可以知道，“定義后”打印的也是堆的地址。
那么如何證明“block內(nèi)部”打印的是堆地址？
把三個16進制的內(nèi)存地址轉(zhuǎn)成10進制就是：
- 定義后前：6171559672
- block內(nèi)部：5732708296
- 定義后：5732708296
中間相差438851376個字節(jié)，也就是 418.5M 的空間，因為堆地址要小于棧地址，又因為 iOS 中主線程的棧區(qū)內(nèi)存只有1M，Mac也只有8M，既然 iOS 中一條線程最大的?？臻g是1M，顯然a已經(jīng)是在堆區(qū)了。
這也證實了：a 在定義前是棧區(qū)，但只要進入了 block 區(qū)域，就變成了堆區(qū)。
從代碼角度講：
__block int a = 0; // 【a 會被編譯成一個結(jié)構(gòu)體，a struct 里會有一個 a 存儲 0】
NSLog(@"定義前：%p", &a); //棧區(qū)
void (^foo)(void) = ^{
a = 1;
NSLog(@"block內(nèi)部：%p", &a); //堆區(qū)
};
這里會執(zhí)行 copy 操作，下面是編譯后的 copy 方法，a struct 會被拷貝到堆里，自然里面的 a struct->a 也會拷貝到堆里
static void __main_block_copy_0(struct __main_block_impl_0*dst, struct __main_block_impl_0*src) {_Block_object_assign((void*)&dst->a, (void*)src->a, 8/*BLOCK_FIELD_IS_BYREF*/);}
同理可證：
在 ARC 中無論是否添加
__block，block 中的 auto 變量都會被從棧上 copy 到堆上。
證明代碼如下：
__block int a = 0;
int b = 1;
NSLog(@"定義前外部：a：%p", &a); //棧區(qū)
NSLog(@"定義前外部：b：%p", &b); //棧區(qū)
void (^foo)(void) = ^{
a = 1;
NSLog(@"block內(nèi)部：a：%p", &a); //堆區(qū)
NSLog(@"block內(nèi)部：b：%p", &b); //堆區(qū)
};
NSLog(@"定義后外部：a：%p", &a); //堆區(qū)
NSLog(@"定義后外部：b：%p", &b); //棧區(qū)
foo();
打印是：
2020-06-08 12:59:43.633180+0800 Demo_38_block_edit_var[35375:7813379] 定義前外部：a：0x7ffee3d81078
2020-06-08 12:59:43.633328+0800 Demo_38_block_edit_var[35375:7813379] 定義前外部：b：0x7ffee3d8105c
2020-06-08 12:59:43.633535+0800 Demo_38_block_edit_var[35375:7813379] 定義后外部：a：0x600003683578
2020-06-08 12:59:43.633640+0800 Demo_38_block_edit_var[35375:7813379] 定義后外部：b：0x7ffee3d8105c
2020-06-08 12:59:43.633754+0800 Demo_38_block_edit_var[35375:7813379] block內(nèi)部：a：0x600003683578
2020-06-08 12:59:43.633859+0800 Demo_38_block_edit_var[35375:7813379] block內(nèi)部：b：0x6000038ff628
__block 關(guān)鍵字修飾后，int類型也從4字節(jié)變成了32字節(jié)，這是 Foundation 框架 malloc 出來的。這也同樣能證實上面的結(jié)論。（PS：居然比 NSObject alloc 出來的 16 字節(jié)要多一倍）。
改外部變量必要條件之“將 auto 變量封裝為結(jié)構(gòu)體(對象)”
正如上文提到的：
我們都知道：Block不允許修改外部變量的值，這里所說的外部變量的值，指的是棧中 auto 變量。
__block作用是將 auto 變量封裝為結(jié)構(gòu)體(對象)，在結(jié)構(gòu)體內(nèi)部新建一個同名 auto 變量，block 內(nèi)截獲該結(jié)構(gòu)體的指針，在 block 中使用自動變量時，使用指針指向的結(jié)構(gòu)體中的自動變量。于是就可以達到修改外部變量的作用。
如果把編譯器的“不允許修改外部”這種行為理解為：對 block 內(nèi)部捕獲到的 auto 變量設置為只讀屬性---不允許直接修改。
那么 __block 的作用就是創(chuàng)建了一個函數(shù)，允許你通過這個函數(shù)修改“對外只讀”的屬性。
屬性對外只讀，但是對外提供專門的修改值的方法，在開發(fā)中這種做法非常常見。
自動變量生成的結(jié)構(gòu)體：
struct __Block_byref_c_0 {
void *__isa;
__Block_byref_c_0 *__forwarding;
int __flags;
int __size;
//自動變量
int c;
};
block:
struct __main_block_impl_0 {
struct __block_impl impl;
struct __main_block_desc_0* Desc;
//截獲的結(jié)構(gòu)體指針
__Block_byref_c_0 *c; // by ref
__main_block_impl_0(void *fp, struct __main_block_desc_0 *desc, __Block_byref_c_0 *_c, int flags=0) : c(_c->__forwarding) {
impl.isa = &_NSConcreteStackBlock;
impl.Flags = flags;
impl.FuncPtr = fp;
Desc = desc;
}
};
block中使用自動變量：
static int __main_block_func_0(struct __main_block_impl_0 *__cself, int a) {
//指針
__Block_byref_c_0 *c = __cself->c; // bound by ref
(c->__forwarding->c) = 11;
a = a + (c->__forwarding->c);
return a;
}
理解到這是因為添加了修改只讀屬性的方法，而非所謂的“寫操作生效”，這一點至關(guān)重要，要不然你如何解釋下面這個現(xiàn)象：
以下代碼編譯可以通過，并且在 block 中成功將 a 的從 Tom 修改為 Jerry。
NSMutableString *a = [NSMutableString stringWithString:@"Tom"];
void (^foo)(void) = ^{
a.string = @"Jerry";
//a = [NSMutableString stringWithString:@"William"]; //編譯報錯
};
foo();
同理如下操作也是允許的：
//
// main.m
// Demo_38_block_edit_var
//
// Created by chenyilong on 2020/6/3.
// Copyright ? 2020 ChenYilong. All rights reserved.
//
#import <UIKit/UIKit.h>
#import "AppDelegate.h"
typedef void (^CYLBlock)(void);
int main(int argc, char * argv[]) {
NSString * appDelegateClassName;
@autoreleasepool {
appDelegateClassName = NSStringFromClass([AppDelegate class]);
NSMutableArray *array = [[NSMutableArray array] init];
CYLBlock block = ^{
[array addobject: 0"123"];
array = nil; //編譯報錯
};
block();
}
return UIApplicationMain(argc, argv, nil, appDelegateClassName);
}
以上都是在使用變量而非修改變量，所以不會編譯報錯。
