关于block在内存中的位置，
这篇文章解释的不错，但是好像并没有区分arc和mrc的区别
block的位置分为这几种
NSGlobalBlock：类似函数，位于text段；
NSStackBlock：位于栈内存，函数返回后Block将无效；
NSMallocBlock：位于堆内存。
不引用外部环境变量的block都属于NSGlobalBlock，&NSStackBlock和NSMallocBlock在arc和mrc下有所不同，mrc下引用外部环境变量的block属于NSStackBlock，对NSStackBlock的copy产生NSMallocBlock；而在arc下统一都是NSMallocBlock。
所以这样一段代码
int (^plus1)(int a, int b)=^int(int a, int b){
return a+b;
NSLog(@"plus1 = %@",plus1);
int c = 100;
int(^plus2)(int a, int b) = ^int(int a, int b){
return c+a+b;
NSLog(@"plus2 = %@",plus2);
&arc下输出是：
plus1 = &__NSGlobalBlock__: 0x10a5ac350&
plus2 = &__NSMallocBlock__: 0x7fdecbf41270&
mrc下输出是：
plus1 = &__NSGlobalBlock__: 0x10f55b350&
plus2 = &__NSStackBlock__: 0x7fff50bdebe0&
&那是不是arc下面不会出现NSStackBlock呢，测试下面一段代码：
__weak int(^plus2_5)(int a, int b) = ^int(int a, int b){
return c+a+b;
NSLog(@"plus2_5 = %@",plus2_5);
__weak int(^plus3)(int a, int b) = plus2;
NSLog(@"plus3 = %@",plus3);
NSLog(@"plus4 = %@",^int(){
plus2_5 = &__NSStackBlock__: 0x7fff5bcfcbb8&
plus3 = &__NSMallocBlock__: 0x7f7f7b625110&
plus4 = &__NSStackBlock__: 0x7fff5bcfcb78&
可以看出单独对block的声明，block还是会分布在栈上。而plus3为什么分布在了堆上，这是因为plus3的声明类似于［plus2 copy］，自然要将其拷贝到堆上。
阅读(...) 评论()block使用小结、在arc中使用block、如何防止循环引用(zz)
zz from&/?p=255
使用block已经有一段时间了，感觉自己了解的还行，但是几天前看到CocoaChina上一个关于block的小测试，发现竟然做错了几道,
才知道自己想当然的理解是错误的，所以抽时间学习了下，并且通过一些测试代码进行测试，产生这篇博客。
Block简介（copy一段）
Block作为C语言的扩展，并不是高新技术，和其他语言的闭包或lambda表达式是一回事。需要注意的是由于Objective-C在iOS中不支持GC机制，使用Block必须自己管理内存，而内存管理正是使用Block坑最多的地方，错误的内存管理
要么导致return
cycle内存泄漏要么内存被提前释放导致crash。
Block的使用很像函数指针，不过与函数最大的不同是：Block可以访问函数以外、词法作用域以内的外部变量的值。换句话说，Block不仅
实现函数的功能，还能携带函数的执行环境。
可以这样理解，Block其实包含两个部分内容
Block执行的代码，这是在编译的时候已经生成好的；
一个包含Block执行时需要的所有外部变量值的数据结构。
Block将使用到的、作用域附近到的变量的值建立一份快照拷贝到栈上。
Block与函数另一个不同是，Block类似ObjC的对象，可以使用自动释放池管理内存（但Block并不完全等同于ObjC对象，后面将详细说明）。
Block基本语法
基本语法在本文就不赘述了，同学们自学。
Block的类型与内存管理
根据Block在内存中的位置分为三种类型NSGlobalBlock，NSStackBlock,
NSMallocBlock。
NSGlobalBlock：类似函数，位于text段；
NSStackBlock：位于栈内存，函数返回后Block将无效；
NSMallocBlock：位于堆内存。
1、NSGlobalBlock如下，我们可以通过是否引用外部变量识别，未引用外部变量即为NSGlobalBlock，可以当做函数使用。
&&&&//create
a NSGlobalBlock
(^sum)(float, float) =
^(float a, float b){
&&&&&&&&return
&&&&NSLog(@"block
is %@", sum); //block is
&__NSGlobalBlock__: 0x47d0&
2、NSStackBlock如下：
&&&&NSArray
*testArr = @[@"1", @"2"];
(^TestBlock)(void) = ^{
&&&&&&&&NSLog(@"testArr
:%@", testArr);
&&&&NSLog(@"block
is %@", ^{
&&&&&&&&NSLog(@"test
Arr :%@", testArr);
&&&&//block
is &__NSStackBlock__: 0xbfffdac0&
&&&&//打印可看出block是一个
NSStackBlock, 即在栈上,
当函数返回时block将无效
&&&&NSLog(@"block
is %@", TestBlock);
&&&&//block
is &__NSMallocBlock__: 0x75425a0&
&&&&//上面这句在非arc中打印是
NSStackBlock, 但是在arc中就是NSMallocBlock
&&&&//即在arc中默认会将block从栈复制到堆上，而在非arc中，则需要手动copy.
3、NSMallocBlock只需要对NSStackBlock进行copy操作就可以获取，但是retain操作就不行,会在下面说明
Block的copy、retain、release操作
（还是copy一段）
不同于NSObjec的copy、retain、release操作：
Block_copy与copy等效，Block_release与release等效；
对Block不管是retain、copy、release都不会改变引用计数retainCount，retainCount始终是1；
NSGlobalBlock：retain、copy、release操作都无效；
NSStackBlock：retain、release操作无效，必须注意的是，NSStackBlock在函数返回后，Block内存将被回收。即使retain也没用。容易犯的错误是[[mutableAarry
addObject:stackBlock]，（补：在arc中不用担心此问题，因为arc中会默认将实例化的block拷贝到堆上）在函数出栈后，从mutableAarry中取到的stackBlock已经被回收，变成了野指针。正确的做法是先将stackBlock
copy到堆上，然后加入数组：[mutableAarry
addObject:[[stackBlock copy]
autorelease]]。支持copy，copy之后生成新的NSMallocBlock类型对象。
NSMallocBlock支持retain、release，虽然retainCount始终是1，但内存管理器中仍然会增加、减少计数。copy之后不会生成新的对象，只是增加了一次引用，类似retain；
尽量不要对Block使用retain操作。
Block对外部变量的存取管理
基本数据类型
1、局部变量
局部自动变量，在Block中只读。Block定义时copy变量的值，在Block中作为常量使用，所以即使变量的值在Block外改变，也不影响他在Block中的值。
base = 100;
(^sum)(int, int) = ^ long
(int a, int b) {
&&&&&&&&return
base + a +
&&&&printf("%ld\n",sum(1,2));
这里输出是103，而不是3,
因为块内base为拷贝的常量 100
2、STATIC修饰符的全局变量
因为全局变量或静态变量在内存中的地址是固定的，Block在读取该变量值的时候是直接从其所在内存读出，获取到的是最新值，而不是在定义时copy的常量.
&&&&static
int base = 100;
(^sum)(int, int) = ^ long
(int a, int b) {
&&&&&&&&base++;
&&&&&&&&return
base + a +
&&&&printf("%ld\n",sum(1,2));
这里输出是4，而不是103,
因为base被设置为了0
&&&&printf("%d\n",
这里输出1，
因为sum中将base++了
3、__BLOCK修饰的变量
Block变量，被__block修饰的变量称作Block变量。
基本类型的Block变量等效于全局变量、或静态变量。
注：BLOCK被另一个BLOCK使用时，另一个BLOCK被COPY到堆上时，被使用的BLOCK也会被COPY。但作为参数的BLOCK是不会发生COPY的
block对于objc对象的内存管理较为复杂，这里要分static
global local
block变量分析、还要分非arc和arc分析
非ARC中的变量
先看一段代码(非arc)
@interface MyClass : NSObject
&&&&NSObject*
_instanceO
@implementation MyClass
NSObject* __globalObj =
- (id) init {
(self = [super
&&&&&&&&_instanceObj
= [[NSObject alloc]
&&&&return
- (void) test {
&&&&static
NSObject* __staticObj = nil;
&&&&__globalObj
= [[NSObject alloc]
&&&&__staticObj
= [[NSObject alloc]
&&&&NSObject*
localObj = [[NSObject alloc]
&&&&__block
NSObject* blockObj = [[NSObject
alloc] init];
&&&&typedef
void (^MyBlock)(void) ;
&&&&MyBlock
aBlock = ^{
&&&&&&&&NSLog(@"%@",
__globalObj);
&&&&&&&&NSLog(@"%@",
__staticObj);
&&&&&&&&NSLog(@"%@",
_instanceObj);
&&&&&&&&NSLog(@"%@",
localObj);
&&&&&&&&NSLog(@"%@",
blockObj);
&&&&aBlock
= [[aBlock copy]
autorelease];
&&&&aBlock();
&&&&NSLog(@"%d",
[__globalObj retainCount]);
&&&&NSLog(@"%d",
[__staticObj retainCount]);
&&&&NSLog(@"%d",
[_instanceObj retainCount]);
&&&&NSLog(@"%d",
[localObj retainCount]);
&&&&NSLog(@"%d",
[blockObj retainCount]);
int main(int argc, char
*argv[]) {
&&&&@autoreleasepool
&&&&&&&&MyClass*
obj = [[[MyClass alloc]
init] autorelease];
&&&&&&&&[obj
&&&&&&&&return
执行结果为1 1 1 2 1。
__globalObj和__staticObj在内存中的位置是确定的，所以Block
copy时不会retain对象。
_instanceObj在Block copy时也没有直接retain
_instanceObj对象本身，但会retain
self。所以在Block中可以直接读写_instanceObj变量。
localObj在Block
copy时，系统自动retain对象，增加其引用计数。
blockObj在Block
copy时也不会retain。
ARC中的变量测试
由于arc中没有retain，retainCount的概念。只有强引用和弱引用的概念。当一个变量没有__strong的指针指向它时，就会被系统释放。因此我们可以通过下面的代码来测试。
代码片段1(globalObject全局变量)
NSString *__globalString =
- (void)testGlobalObj
&&&&__globalString
(^TestBlock)(void) = ^{
&&&&&&&&NSLog(@"string
is :%@", __globalString); //string is
/blog/wp-includes/images/smilies/icon_sad.gif"
alt=":(" class="wp-smiley"& null)
&&&&__globalString
&&&&TestBlock();
- (void)testStaticObj
&&&&static
NSString *__staticString =
&&&&__staticString
&&&&printf("static
address: %p\n",
&__staticString);&&&
//static address: 0x6a8c
(^TestBlock)(void) = ^{
&&&&&&&&printf("static
address: %p\n", &__staticString);
//static address: 0x6a8c
&&&&&&&&NSLog(@"string
is : %@", __staticString); //string is
/blog/wp-includes/images/smilies/icon_sad.gif"
alt=":(" class="wp-smiley"& null)
&&&&__staticString
&&&&TestBlock();
- (void)testLocalObj
&&&&NSString
*__localString = nil;
&&&&__localString
&&&&printf("local
address: %p\n",
&__localString); //local address:
0xbfffd9c0
(^TestBlock)(void) = ^{
&&&&&&&&printf("local
address: %p\n", &__localString);
//local address: 0x71723e4
&&&&&&&&NSLog(@"string
is : %@", __localString); //string is : 1
&&&&__localString
&&&&TestBlock();
- (void)testBlockObj
&&&&__block
NSString *_blockString = @"1";
(^TestBlock)(void) = ^{
&&&&&&&&NSLog(@"string
is : %@", _blockString); // string is
/blog/wp-includes/images/smilies/icon_sad.gif"
alt=":(" class="wp-smiley"& null)
&&&&_blockString
&&&&TestBlock();
- (void)testWeakObj
&&&&NSString
*__localString = @"1";
&&&&__weak
NSString *weakString = __localS
&&&&printf("weak
address: %p\n",
&weakString);& //weak
address: 0xbfffd9c4
&&&&printf("weak
str address: %p\n", weakString); //weak str
address: 0x684c
(^TestBlock)(void) = ^{
&&&&&&&&printf("weak
address: %p\n", &weakString); //weak
address: 0x7144324
&&&&&&&&printf("weak
str address: %p\n", weakString); //weak str
address: 0x684c
&&&&&&&&NSLog(@"string
is : %@", weakString); //string is :1
&&&&__localString
&&&&TestBlock();
由以上几个测试我们可以得出：
1、只有在使用local变量时，block会复制指针，且强引用指针指向的对象一次。其它如全局变量、static变量、block变量等，block不会拷贝指针,只会强引用指针指向的对象一次。
2、即时标记了为__weak或__unsafe_unretained的local变量。block仍会强引用指针对象一次。（这个不太明白，因为这种写法可在后面避免循环引用的问题）
循环引用retain
循环引用指两个对象相互强引用了对方，即retain了对方，从而导致谁也释放不了谁的内存泄露问题。如声明一个delegate时一般用assign而不能用retain或strong，因为你一旦那么做了，很大可能引起循环引用。在以往的项目中，我几次用动态内存检查发现了循环引用导致的内存泄露。
这里讲的是block的循环引用问题，因为block在拷贝到堆上的时候，会retain其引用的外部变量，那么如果block中如果引用了他的宿主对象，那很有可能引起循环引用，如：
self.myblock = ^{
&&&&&&&&&&&&[self
doSomething];
&&&&&&&&};
为测试循环引用，写了些测试代码用于避免循环引用的方法，如下，（只有arc的，懒得做非arc测试了）
- (void)dealloc
&&&&NSLog(@"no
cycle retain");
- (id)init
= [super init];
#if TestCycleRetainCase1
&&&&&&&&//会循环引用
&&&&&&&&self.myblock
&&&&&&&&&&&&[self
doSomething];
&&&&&&&&};
#elif TestCycleRetainCase2
&&&&&&&&//会循环引用
&&&&&&&&__block
TestCycleRetain *weakSelf = self;
&&&&&&&&self.myblock
&&&&&&&&&&&&[weakSelf
doSomething];
&&&&&&&&};
#elif TestCycleRetainCase3
&&&&&&&&//不会循环引用
&&&&&&&&__weak
TestCycleRetain *weakSelf = self;
&&&&&&&&self.myblock
&&&&&&&&&&&&[weakSelf
doSomething];
&&&&&&&&};
#elif TestCycleRetainCase4
&&&&&&&&//不会循环引用
&&&&&&&&__unsafe_unretained
TestCycleRetain *weakSelf = self;
&&&&&&&&self.myblock
&&&&&&&&&&&&[weakSelf
doSomething];
&&&&&&&&};
&&&&&&&&NSLog(@"myblock
is %@", self.myblock);
&&&&return
- (void)doSomething
&&&&NSLog(@"do
Something");
int main(int argc, char
*argv[]) {
&&&&@autoreleasepool
&&&&&&&&TestCycleRetain*
obj = [[TestCycleRetain alloc]
&&&&&&&&obj
&&&&&&&&return
经过上面的测试发现，在加了__weak和__unsafe_unretained的变量引入后，TestCycleRetain方法可以正常执行dealloc方法，而不转换和用__block转换的变量都会引起循环引用。
因此防止循环引用的方法如下：
__unsafe_unretained TestCycleRetain *weakSelf =
In manual reference counting
mode,&__block
the effect of not retaining&x.
In ARC mode,&__block
to retaining&x&(just
like all other values). To get the manual reference counting mode
behavior under ARC, you could
use&__unsafe_unretained
As the name&__unsafe_unretained&implies,
however, having a non-retained variable is dangerous (because it
can dangle) and is therefore discouraged. Two better options are to
either use&__weak&(if
you don’t need to support iOS&4 or
OS&X&v10.6), or set
the&__block&value
break the retain cycle.
以上网友发言只代表其个人观点，不代表新浪网的观点或立场。block 有什么意义，特点等等，这些东西，实在是太复杂了，这里只是简单的总结一下block的内存管理。而且也仅仅限于objective-C的部分
Block memoryblock 的内存管理，应该是最头疼的地方,就用这个来自WWDC的例子来解释一下吧。
当程序运行到这里时，stack 空间中有 shared 变量和 captured 变量。
这里可以看出，__block 变量开始是处于stack上的。
当程序运行到这里时，stack 空间中有 shared 变量，captured 变量和block1。
这里可以看出，block 类型的变量开始时也是处在stack上的。
当程序运行到这里时，stack 空间中有 shared 变量，captured 变量和block1。
这里值得注意的就是当我们直接修改stack 上的captured变量时，block1中的captured变量仍然是原来的数值10。事实上，从const 我们就可以看出，block1中的captured变量是不能被修改的而且是从stack原有变量的一个const 拷贝。在block1中访问的captured变量是const拷贝的，也就是说block1中captured = 10，而不是原有的stack上的值 20。当然，在block1中，我们也不能修改captured变量。
Copy blockblock在一开始是处在stack上的，这是为了考虑到效率的原因，但是，有时候是需要block的生命周期长于一开始的stack，这时，我们就通过copy block 来将block复制到heap。
当程序执行完 block2 = [block1 copy];时，__block 类型变量shared，被复制到了heap中，很显然，shared变量需要被block和block2共享(当然还有stack也要共享)，而block2被移动到heap中，很可能生命周期会长于stack，所以，shared也被复制到了heap中。而block2中的captured 也被复制到了heap中。
当程序执行完 block3 = [block2 copy];时, 我们看到的是，block2 和block3 其实指向的是同一片内存空间。事实上，block的数据结构中，保存了引用计数，而对于copy到heap中的block 再copy时，行为同普通对象retain一样，会使引用计数+1。那么如果我们对[block retain]会如何呢？ 实际上什么都没有发生，至少在现在的runtime版本下。因为retain中，不仅有引用计数+1在，而且retain的返回值，必须同返回调用对象的地址一样，而block的地址是可能变化的（stack or heap），所以，这里retain的行为几乎是被忽略掉的。
当heap中的block变量先于stack被销毁时，如调用 [block2 release]; [block3 release];，heap中的block2，block3 由于引用计数为0 而被销毁，而 __block 变量shared则还在heap中，因为stack还要使用，block1 也要使用。
当heap中的block变量晚于stack时，显然，stack 被清除，function中也啥都没了。
最后，当block2 和block3 都被release之后。则恢复到最初状态
block details当我们写出一个Block literal expression{ printf("hello worldn"); }1事实上，编译器为我们生成了如下结构
struct __block_literal_1 {


void *






void (*invoke)(struct __block_literal_1 *);


struct __block_descriptor_1 *

};void __block_invoke_1(struct __block_literal_1 *_block) {


printf("hello worldn");

}static struct __block_descriptor_1 {


unsign


unsigned long int Block_

} __block_descriptor_1 = { 0, sizeof(struct __block_literal_1)}; 当Block literal expression 使用时 __block_literal_1 则会被初始化为：struct __block_literal_1 _block_literal = {


&_NSConcreteStackBlock,


(1<<29), <uninitialized>,


__block_invoke_1,


&__block_descriptor_1


下一个例子1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253int x = 10;void (^vv)(void) = ^{printf("x is %dn", x);};x = 11;vv();编译器会生成如下结构struct __block_literal_2{
void (*invoke)(struct __block_literal_2 *);
struct __block_descriptor_2 *
const int};void __block_invoke_2(struct __block_literal_2 *_block){
printf("x is %dn", _block-&x);}void struct __block_descriptor_2{
unsigned long int
unsigned long int block_}__block_descriptor_2 = {0, sizeof(struct __block_literal_2)};struct __block_literal_2 __block_literal_2 = {
&NSConcreteStackBlock,
__block_invoke_2,
&__block_descriptor_2,
block中使用的普通变量（int， char *）导入是const copy。普通对象则会retain。__block 类型变量则什么不做，只是保存一个指针，全局变量也只是保存一个简单的指针。
当然，block 可能也会嵌套block，那么又会是什么样子？其实不复杂，复杂的只是增加了复制函数，和释放函数，这一点很像C++的拷贝构造函数，在必要时生成。12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667686970717273747576777879808182838485objcvoid (^existingBlock)(void) = …;void (^vv)(void) = ^{existingBlock();};vv();struct __block_literal_3{
...;};struct __block_literal_4{
void (*invoke)(struct __block_literal_4 *);
struct __block_literal_3 *const existingB};void __block_invoke_4(struct __block_literal_3 *__block) {
__block-&existingBlock-&invoke(__block-&existingBlock);}void __block_copy_4(struct __block_literal_4 *dst, struct __block_literal_4 *src) {
_Block_object_assign(&dst-&existingBlock, src-&existingBlock, BLOCK_FIELD_IS_BLOCK);}void __block_dispose_4(struct __block_literal_4 *src) {
_Block_object_dispose(src-&existingBlock, BLOCK_FIELD_IS_BLOCK);}static struct __block_descriptor_4 {
unsigned long int
unsigned long int Block_
void (*copy_helper)(struct __block_literal_4 *dst, struct __block_literal_4 *src);
void (*dispose_helper)(struct __block_literal_4 *);} __block_descriptor_4 = {
sizeof(struct __block_literal_4),
__block_copy_4,
__block_dispose_4,};初始化
struct __block_literal_4 _block_literal = {
&_NSConcreteStackBlock,
(1&&25)|(1&&29), &uninitialized&
__block_invoke_4,
&__block_descriptor_4
existingBlock,
__block storage variables__block
变量是一种很特殊的数据类型，有自己的特有的数据结构12345678910111213141516171819struct _block_byref_xxxx {
struct _block_byref_xxxx *
void (*byref_keep)(void
*dst, void *src);
void (*byref_dispose)(void *);
typeof(marked_variable) marked_};
看看__block 类型变量的使用12345678910111213141516171819int __block i = 10;i = 11;struct _block_byref_i {
struct _block_byref_i *
int captured_i;} i = { NULL, &i, 0, sizeof(struct _block_byref_i), 10 };i.forwarding-&captured_i = 11;
显然，当block中增加了block 类型变量之后，嵌套block 的拷贝函数也会增加对block 变量的复制。12345678910111213141516171819202122232425262728293031323334353637383940414243__block void (voidBlock)(void) = blockA;voidBlock = blockB;struct _block_byref_voidBlock {
struct _block_byref_voidBlock *
void (*byref_keep)(struct _block_byref_voidBlock *dst, struct _block_byref_voidBlock *src);
void (*byref_dispose)(struct _block_byref_voidBlock *);
void (^captured_voidBlock)(void);};void _block_byref_keep_helper(struct _block_byref_voidBlock *dst, struct _block_byref_voidBlock *src) {
_Block_object_assign(&dst-&captured_voidBlock, src-&captured_voidBlock, BLOCK_FIELD_IS_BLOCK | BLOCK_BYREF_CALLER);}void _block_byref_dispose_helper(struct _block_byref_voidBlock *param) {
_Block_object_dispose(param-&captured_voidBlock, BLOCK_FIELD_IS_BLOCK | BLOCK_BYREF_CALLER)}struct _block_byref_voidBlock voidBlock = {( .forwarding=&voidBlock, .flags=(1&&25), .size=sizeof(struct _block_byref_voidBlock *),
.byref_keep=_block_byref_keep_helper, .byref_dispose=_block_byref_dispose_helper,
.captured_voidBlock=blockA )};voidBlock.forwarding-&captured_voidBlock = blockB;
block中，引入了__block 会是什么情况1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768697071727374757677787980818283int __block i = 2;functioncall(^{ i = 10; });struct _block_byref_i {
struct _block_byref_voidBlock *
void (*byref_keep)(struct _block_byref_i *dst, struct _block_byref_i *src);
void (*byref_dispose)(struct _block_byref_i *);
int captured_i;};struct __block_literal_5 {
void (*invoke)(struct __block_literal_5 *);
struct __block_descriptor_5 *
struct _block_byref_i *i_};void __block_invoke_5(struct __block_literal_5 *_block) {
_block-&i_holder-&forwarding-&captured_i = 10;}void __block_copy_5(struct __block_literal_5 *dst, struct __block_literal_5 *src) {
_Block_object_assign(&dst-&i_holder, src-&i_holder, BLOCK_FIELD_IS_BYREF | BLOCK_BYREF_CALLER);}void __block_dispose_5(struct __block_literal_5 *src) {
_Block_object_dispose(src-&i_holder, BLOCK_FIELD_IS_BYREF | BLOCK_BYREF_CALLER);}static struct __block_descriptor_5 {
unsigned long int
unsigned long int Block_
void (*copy_helper)(struct __block_literal_5 *dst, struct __block_literal_5 *src);
void (*dispose_helper)(struct __block_literal_5 *);} __block_descriptor_5 = { 0, sizeof(struct __block_literal_5) __block_copy_5, __block_dispose_5 };struct _block_byref_i i = {( .forwarding=&i, .flags=0, .size=sizeof(struct _block_byref_i) )};struct __block_literal_5 _block_literal = {
&_NSConcreteStackBlock,
(1&&25)|(1&&29), &uninitialized&,
__block_invoke_5,
&__block_descriptor_5,
block 中的太多细节这里不做赘述，有兴趣的可以参考Block—ABI-Apple，也可以直接去看。