全面解析ObjectiveC中的block代码块的使用模板Word格式文档下载.docx
《全面解析ObjectiveC中的block代码块的使用模板Word格式文档下载.docx》由会员分享，可在线阅读，更多相关《全面解析ObjectiveC中的block代码块的使用模板Word格式文档下载.docx（15页珍藏版）》请在冰豆网上搜索。
程序代码区：
这个区域主要存放函数体的二进制代码。
下面举一个前辈写的例子：
//main.cpp
inta=0;
//全局初始化区
char*p1;
//全局未初始化区
main{
intb;
//栈
chars[]="
abc"
;
char*p2;
char*p3="
123456"
//123456\0在常量区，p3在栈上
staticintc=0；
//全局静态初始化区
p1=（char*）malloc（10）;
p2=（char*）malloc（20）;
//分配得来的10和20字节的区域就在堆区
strcpy（p1,"
）;
//123456\0在常量区，这个函数的作用是将"
这串字符串复制一份放在p1申请的10个字节的堆区域中。
//p3指向的"
与这里的"
可能会被编译器优化成一个地址。
}
strcpy函数
原型声明：
externchar*strcpy（char*dest,constchar*src）;
功能：
把从src地址开始且含有NULL结束符的字符串复制到以dest开始的地址空间。
1.2结构体（Struct）
在C语言中，结构体（struct）指的是一种数据结构。
结构体可以被声明为变量、指针或数组等，用以实现较复杂的数据结构。
结构体同时也是一些元素的集合，这些元素称为结构体的成员（member），且这些成员可以为不同的类型，成员一般用名字访问。
我们来看看结构体的定义：
structtag{member-list}variable-list;
1.struct：
结构体关键字。
2.tag：
结构体标签。
3.member-list：
结构体成员列表。
4.variable-list：
为结构体声明的变量列表。
在一般情况下，tag，member-list，variable-list这三部分至少要出现两个。
以下为示例：
//该结构体拥有3个成员，整型的a，字符型的b，双精度型的c
//并且为该结构体声明了一个变量s1
//该结构体没有标明其标签
struct{
inta;
charb;
doublec;
}s1;
//该结构体拥有同样的三个成员
//并且该结构体标明了标签EXAMPLE
//该结构体没有声明变量
structEXAMPLE{
};
//用EXAMPLE标签的结构体，另外声明了变量t1、t2、t3
structEXAMPLEt1,t2[20],*t3;
以上就是简单结构体的代码示例。
结构体的成员可以包含其他结构体，也可以包含指向自己结构体类型的指针。
结构体的变量也可以是指针。
下面我们来看看结构体成员的访问。
结构体成员依据结构体变量类型的不同，一般有2种访问方式，一种为直接访问，一种为间接访问。
直接访问应用于普通的结构体变量，间接访问应用于指向结构体变量的指针。
直接访问使用结构体变量名.成员名，间接访问使用（*结构体指针名）.成员名或者使用结构体指针名->
成员名。
相同的成员名称依靠不同的变量前缀区分。
//声明结构体变量s1和指向结构体变量的指针s2
structEXAMPLEs1,*s2;
//给变量s1和s2的成员赋值,注意s1.a和s2->
a并不是同一成员
s1.a=5;
s1.b=6;
s2->
a=3;
b=4;
最后我们来看看结构体成员存储。
在内存中，编译器按照成员列表顺序分别为每个结构体成员分配内存。
如果想确认结构体占多少存储空间，则使用关键字sizeof，如果想得知结构体的某个特定成员在结构体的位置，则使用offsetof宏（定义于stddef.h）。
//获得EXAMPLE类型结构体所占内存大小
intsize_example=sizeof（structEXAMPLE）;
//获得成员b相对于EXAMPLE储存地址的偏移量
intoffset_b=offsetof（structEXAMPLE,b）;
1.3闭包（Closure）
闭包就是一个函数，或者一个指向函数的指针，加上这个函数执行的非局部变量。
说的通俗一点，就是闭包允许一个函数访问声明该函数运行上下文中的变量，甚至可以访问不同运行上文中的变量。
我们用脚本语言来看一下：
functionfunA（callback）{
alert（callback（））;
functionfunB（）{
varstr="
HelloWorld"
//函数funB的局部变量，函数funA的非局部变量
funA（
function（）{
returnstr;
）；
通过上面的代码我们可以看出，按常规思维来说，变量str是函数funB的局部变量，作用域只在函数funB中，函数funA是无法访问到str的。
但是上述代码示例中函数funA中的callback可以访问到str，这是为什么呢，因为闭包性。
2.blcok基础知识
block实际上就是Objective-C语言对闭包的实现。
2.1block的原型及定义
我们来看看block的原型：
NSString*（^myBlock）（int）;
上面的代码声明了一个block（^）原型，名字叫做myBlock，包含一个int型的参数，返回值为NSString类型的指针。
下面来看看block的定义：
myBlock=^（intparamA）
{
return[NSStringstringWithFormat:
@"
Passednumber:
%i"
paramA];
上面的代码中，将一个函数体赋值给了myBlock变量，其接收一个名为paramA的参数，返回一个NSString对象。
注意：
一定不要忘记block后面的分号。
定义好block后，就可以像使用标准函数一样使用它了：
myBlock（7）;
由于block数据类型的语法会降低整个代码的阅读性，所以常使用typedef来定义block类型。
例如，下面的代码创建了GetPersonEducationInfo和GetPersonFamilyInfo两个新类型，这样我们就可以在下面的方法中使用更加有语义的数据类型。
//Person.h
#import//Defineanewtypefortheblock
typedefNSString*（^GetPersonEducationInfo）（NSString*）;
typedefNSString*（^GetPersonFamilyInfo）（NSString*）;
@interfacePerson:
NSObject
-（NSString*）getPersonInfoWithEducation:
（GetPersonEducationInfo）educationInfo
andFamily:
（GetPersonFamilyInfo）familyInfo;
@end
我们用一张大师文章里的图来总结一下block的结构：
2.2将block作为参数传递
//.h
-（void）testBlock:
（NSString*（^）（int））myBlock;
//.m
（NSString*（^）（int））myBlock
NSLog（@"
Blockreturned:
%@"
myBlock（7））;
由于Objective-C是强制类型语言，所以作为函数参数的block也必须要指定返回值的类型，以及相关参数类型。
2.3闭包性
上文说过，block实际是Objc对闭包的实现。
我们来看看下面代码：
#importvoidlogBlock（int（^theBlock）（void））
NSLog（@"
ClosurevarX:
theBlock（））;
intmain（void）
NSAutoreleasePool*pool;
int（^myBlock）（void）;
intx;
pool=[[NSAutoreleasePoolalloc]init];
x=42;
myBlock=^（void）
returnx;
logBlock（myBlock）;
[poolrelease];
returnEXIT_SUCCESS;
上面的代码在main函数中声明了一个整型，并赋值42，另外还声明了一个block，该block会将42返回。
然后将block传递给logBlock函数，该函数会显示出返回的值42。
即使是在函数logBlock中执行block，而block又声明在main函数中，但是block仍然可以访问到x变量，并将这个值返回。
block同样可以访问全局变量，即使是static。
2.4block中变量的复制与修改
对于block外的变量引用，block默认是将其复制到其数据结构中来实现访问的，如下图：
通过block进行闭包的变量是const的。
也就是说不能在block中直接修改这些变量。
来看看当block试着增加x的值时，会发生什么：
x++;
编译器会报错，表明在block中变量x是只读的。
有时候确实需要在block中处理变量，怎么办？
别着急，我们可以用__block关键字来声明变量，这样就可以在block中修改变量了。
基于之前的代码，给x变量添加__block关键字，如下：
__blockintx;
对于用__block修饰的外部变量引用，block是复制其引用地址来实现访问的，如下图：
3.编译器中的block
3.1block的数据结构定义
我们通过大师文章中的一张图来说明：
上图这个结构是在栈中的结构，我们来看看对应的结构体定义：
structBlock_descriptor{
unsignedlongintreserved;
unsignedlongintsize;
void（*copy）（void*dst,void*src）;
void（*dispose）（void*）;
structBlock_layout{
void*isa;
intflags;
intreserved;
void（*invoke）（void*,...）;
structBlock_descriptor*descriptor;
/*Imported*/
从上面代码看出，Block_layout就是对block结构体的定义：
isa指针：
指向表明该block类型的类。
flags：
按bit位表示一些block的附加信息，比如判断block类型、判断block引用计数、判断block是否需要执行辅助函数等。
reserved：
保留变量，我的理解是表示block内部的变量数。
invoke：
函数指针，指向具体的block实现的函数调用地址。
descriptor：
block的附加描述信息，比如保留变量数、block的大小、进行copy或dispose的辅助函数指针。
variables：
因为block有闭包性，所以可以访问block外部的局部变量。
这些variables就是复制到结构体中的外部局部变量或变量的地址。
3.2block的类型
block有几种不同的类型，每种类型都有对应的类，上述中isa指针就是指向这个类。
这里列出常见的三种类型：
_NSConcreteGlobalBlock：
全局的静态block，不会访问任何外部变量，不会涉及到任何拷贝，比如一个空的block。
#includeintmain（）
^{printf（"
Hello,World!
\n"
}（）;
return0;
_NSConcreteStackBlock：
保存在栈中的block，当函数返回时被销毁。
chara='
A'
%c\n"
a）;
_NSConcreteMallocBlock：
保存在堆中的block，当引用计数为0时被销毁。
该类型的block都是由_NSConcreteStackBlock类型的block从栈中复制到堆中形成的。
例如下面代码中，在exampleB_addBlockToArray方法中的block还是_NSConcreteStackBlock类型的，在exampleB方法中就被复制到了堆中，成为_NSConcreteMallocBlock类型的block：
voidexampleB_addBlockToArray（NSMutableArray*array）{
charb='
B'
[arrayaddObject:
^{
printf（"
b）;
}];
voidexampleB（）{
NSMutableArray*array=[NSMutableArrayarray];
exampleB_addBlockToArray（array）;
void（^block）（）=[arrayobjectAtIndex:
0];
block（）;
总结一下：
1._NSConcreteGlobalBlock类型的block要么是空block，要么是不访问任何外部变量的block。
它既不在栈中，也不在堆中，我理解为它可能在内存的全局区。
2._NSConcreteStackBlock类型的block有闭包行为，也就是有访问外部变量，并且该block只且只有有一次执行，因为栈中的空间是可重复使用的，所以当栈中的block执行一次之后就被清除出栈了，所以无法多次使用。
3._NSConcreteMallocBlock类型的block有闭包行为，并且该block需要被多次执行。
当需要多次执行时，就会把该block从栈中复制到堆中，供以多次执行。
3.3编译器如何编译
我们通过一个简单的示例来说明：
#importtypedefvoid（^BlockA）（void）;
__attribute__（（noinline））
voidrunBlockA（BlockAblock）{
voiddoBlockA（）{
BlockAblock=^{
//Emptyblock
runBlockA（block）;
上面的代码定义了一个名为BlockA的block类型，该block在函数doBlockA中实现，并将其作为函数runBlockA的参数，最后在函数doBlockA中调用函数runBloackA。
如果block的创建和调用都在一个函数里面，那么优化器（optimiser）可能会对代码做优化处理，从而导致我们看不到编译器中的一些操作，所以用__attribute__（（noinline））给函数runBlockA添加noinline，这样优化器就不会在doBlockA函数中对runBlockA的调用做内联优化处理。
我们来看看编译器做的工作内容：
#import__attribute__（（noinline））
voidrunBlockA（structBlock_layout*block）{
block->
invoke（）;
voidblock_invoke（structBlock_layout*block）{
//Emptyblockfunction
structBlock_descriptorscriptor;
descriptor->
reserved=0;
size=20;
copy=NULL;
dispose=NULL;
structBlock_layoutblock;
isa=_NSCeteGlobalBlock;
flags=1342177280;
invoke=block_invoke;
descriptor=descriptor;
runBlockA（&
block）;
上面的代码结合block的数据结构定义，我们能很容易得理解编译器内部对block的工作内容。
3.4copy（）和dispose（）
上文中提到，如果我们想要在以后继续使用某个block，就必须要对该block进行拷贝操作，即从栈空间复制到堆空间。
所以拷贝操作就需要调用Block_copy（）函数，block的descriptor中有一个copy（）辅助函数，该函数在Block_copy（）中执行，用于当block需要拷贝对象的时候，拷贝辅助函数会retain住已经拷贝的对象。
既然有有copy那么就应该有release，与Block_copy（）对应的函数是Block_release（），它的作用不言而喻，就是释放我们不需要再使用的block，block的descriptor中有一个dispose（）辅助函数，该函数在Block_release（）中执行，负责做和copy（）辅助函数相反的操作，例如释放掉所有在block中拷贝的变量等。
4.下面来看几个具体的运行示例：
4.1参数是NSString*的代码块
void（^printBlock）（NSString*x）;
printBlock=^（NSString*str）
print:
%@"
str）;
printBlock（@"
helloworld!
"
运行结果是：
4.2代码用在字符串数组排序
NSArray*stringArray=[NSArrayarrayWithObjects:
@"
abc1"
@"
abc21"
abc12"
@"
abc13"
abc05"
nil];
NSComparatorsortBlock=^（idstring1,idstring2）
return[string1compare:
string2];
NSArray*sortArray=[stringArraysortedArrayUsingComparator:
sortBlock];
sortArray:
sortArray）;
运行结果：
1
2
3
4
5
6
7
（
）
4.3代码块的递归调用
代码块想要递归调用，代码块变量必须是全局变量或者是静态变量，这样在程序启动的时候代码块变量就初始化了，可以递归调用
staticvoid（^constblocks）（int）=^（inti）
if（i>
0）{
num:
%d"
i）;
blocks（i-1）;
blocks（3）;
运行打印结果：
4.4在代码块中使用局部变量和全局变量
在代码块中可以使用和改变全局变量
intglobal=1000;
intm
升级会员 