- 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关键字），否则只能修改对象（增删）
网友评论