block的解析

时间 2019-11-19

标签 block 解析繁體版

原文原文链接

1. 操做系统中的栈和堆程序员

咱们先来看看一个由C/C++/OBJC编译的程序占用内存分布的结构：数组

栈区（stack）：由系统自动分配，通常存放函数参数值、局部变量的值等。由编译器自动建立与释放。其操做方式相似于数据结构中的栈，即后进先出、先进后出的原则。数据结构

例如：在函数中申明一个局部变量int b;系统自动在栈中为b开辟空间。闭包

堆区（heap）：通常由程序员申请并指明大小，最终也由程序员释放。若是程序员不释放，程序结束时可能会由OS回收。对于堆区的管理是采用链表式管理的，操做系统有一个记录空闲内存地址的链表，当接收到程序分配内存的申请时，操做系统就会遍历该链表，遍历到一个记录的内存地址大于申请内存的链表节点，并将该节点从该链表中删除，而后将该节点记录的内存地址分配给程序。函数

例如：在C中malloc函数优化

　　　char p;spa

　　　p = (char)malloc(10);操作系统

可是p自己是在栈中的。指针

链表：是一种常见的基础数据结构，通常分为单向链表、双向链表、循环链表。如下为单向链表的结构图：code

单向链表是链表中最简单的一种，它包含两个区域，一个信息域和一个指针域。信息域保存或显示关于节点的信息，指针域储存下一个节点的地址。

上述的空闲内存地址链表的信息域保存的就是空闲内存的地址。

全局区/静态区：顾名思义，全局变量和静态变量存储在这个区域。只不过初始化的全局变量和静态变量存储在一块，未初始化的全局变量和静态变量存储在一块。程序结束后由系统释放。

文字常量区：这个区域主要存储字符串常量。程序结束后由系统释放。

程序代码区：这个区域主要存放函数体的二进制代码。

例子：

　　//main.cpp

　　int a = 0; // 全局初始化区

　　char *p1; // 全局未初始化区

　　main {

　　 int b; // 栈

　　 char s[] = "abc" ; // 栈

　　 char *p2; // 栈

　　 char *p3 = "123456" ; // 123456\0在常量区，p3在栈上　　

　　 static int c =0； // 全局静态初始化区

　　 p1 = (char *)malloc(10);　　

　　 p2 = (char *)malloc(20); // 分配得来的10和20字节的区域就在堆区

　　 strcpy(p1, "123456" );

// 123456\0在常量区，这个函数的做用是将"123456" 这串字符串复制一份放在p1申请的10个字节的堆区域中。

　　 // p3指向的"123456"与这里的"123456"可能会被编译器优化成一个地址。

strcpy函数

原型声明：extern char *strcpy(char* dest, const char *src);

功能：把从src地址开始且含有NULL结束符的字符串复制到以dest开始的地址空间。

2. 结构体（Struct）

在C语言中，结构体(struct)指的是一种数据结构。结构体能够被声明为变量、指针或数组等，用以实现较复杂的数据结构。结构体同时也是一些元素的集合，这些元素称为结构体的成员(member)，且这些成员能够为不一样的类型，成员通常用名字访问。

咱们来看看结构体的定义：struct tag { member-list } variable-list;

struct：结构体关键字。

tag：结构体标签。

member-list：结构体成员列表。

variable-list：为结构体声明的变量列表。

在通常状况下，tag，member-list，variable-list这三部分至少要出现两个。如下为示例：

 
   　　// 该结构体拥有3个成员，整型的a，字符型的b，双精度型的c 
  
   　　// 而且为该结构体声明了一个变量s1 
  
   　　// 该结构体没有标明其标签 
  
   　　struct{ 
  
   int a; 
  
   char b; 
  
   double c; 
  
   　　} s1; 
  
   　　// 该结构体拥有一样的三个成员 
  
   　　// 而且该结构体标明了标签EXAMPLE 
  
   　　// 该结构体没有声明变量 
  
   　　struct EXAMPLE{ 
  
   int a; 
  
   char b; 
  
   double c; 
  
   　　}; 
  
   　　//用EXAMPLE标签的结构体，另外声明了变量t一、t二、t3 
  
   　　struct EXAMPLE t1, t2[20], *t3;

以上就是简单结构体的代码示例。结构体的成员能够包含其余结构体，也能够包含指向本身结构体类型的指针。结构体的变量也能够是指针。

下面咱们来看看结构体成员的访问。结构体成员依据结构体变量类型的不一样，通常有2种访问方式，一种为直接访问，一种为间接访问。直接访问应用于普通的结构体变量，间接访问应用于指向结构体变量的指针。直接访问使用结构体变量名.成员名，间接访问使用(*结构体指针名).成员名或者使用结构体指针名->成员名。相同的成员名称依靠不一样的变量前缀区分。

 
   　　struct EXAMPLE{ 
  
   int a; 
  
   char b; 
  
   　　}; 
  
   　　//声明结构体变量s1和指向结构体变量的指针s2 
  
   　　struct EXAMPLE s1, *s2; 
  
   　　//给变量s1和s2的成员赋值,注意s1.a和s2->a并非同一成员 
  
   　　s1.a = 5; 
  
   　　s1.b = 6; 
  
   　　s2->a = 3; 
  
   　　s2->b = 4;

最后咱们来看看结构体成员存储。在内存中，编译器按照成员列表顺序分别为每一个结构体成员分配内存。若是想确认结构体占多少存储空间，则使用关键字sizeof，若是想得知结构体的某个特定成员在结构体的位置，则使用offsetof宏(定义于stddef.h)。

　　struct EXAMPLE{　　

　　 int a;

　　 char b;

　　};

　　//得到EXAMPLE类型结构体所占内存大小

　　int size_example = sizeof( struct EXAMPLE );

　　//得到成员b相对于EXAMPLE储存地址的偏移量

　　int offset_b = offsetof( struct EXAMPLE, b );

3 闭包（Closure）

闭包就是一个函数，或者一个指向函数的指针，加上这个函数执行的非局部变量。

说的通俗一点，就是闭包容许一个函数访问声明该函数运行上下文中的变量，甚至能够访问不一样运行上文中的变量。

咱们用脚本语言来看一下：

　　function funA(callback){

　　 alert(callback());

　　}

　　function funB(){

　　 var str = "Hello World" ; // 函数funB的局部变量，函数funA的非局部变量

　　 funA（

　　 function （）{

　　 return str;

　　 }

　　 ）；

　　}

经过上面的代码咱们能够看出，按常规思惟来讲，变量str是函数funB的局部变量，做用域只在函数funB中，函数funA是没法访问到str的。可是上述代码示例中函数funA中的callback能够访问到str，这是为何呢，由于闭包性。

2.blcok基础知识

block实际上就是Objective-C语言对闭包的实现。

2.1 block的原型及定义

咱们来看看block的原型：

　　NSString * ( ^ myBlock )( int );

上面的代码声明了一个block(^)原型，名字叫作myBlock，包含一个int型的参数，返回值为NSString类型的指针。

下面来看看block的定义：

　　myBlock = ^( int paramA )

　　{

　　 return [ NSString stringWithFormat: @ "Passed number: %i" , paramA ];

　　};

上面的代码中，将一个函数体赋值给了myBlock变量，其接收一个名为paramA的参数，返回一个NSString对象。

注意：必定不要忘记block后面的分号。

定义好block后，就能够像使用标准函数同样使用它了：

　　myBlock(1);

因为block数据类型的语法会下降整个代码的阅读性，因此常使用typedef来定义block类型。例如，下面的代码建立了GetPersonEducationInfo和GetPersonFamilyInfo两个新类型，这样咱们就能够在下面的方法中使用更加有语义的数据类型。

 
   　　// Person.h 
  
   　　#import // Define a new type for the block 
  
   　　typedef NSString * (^GetPersonEducationInfo)(NSString *); 
  
   　　typedef NSString * (^GetPersonFamilyInfo)(NSString *); 
  
   　　@interface Person : NSObject 
  
   　　- (NSString *)getPersonInfoWithEducation:(GetPersonEducationInfo)educationInfo 
  
   andFamily:(GetPersonFamilyInfo)familyInfo; 
  
   　　@end

咱们用一张大师文章里的图来总结一下block的结构：

2.2 将block做为参数传递

 
   　　// .h 
  
   　　-(void) testBlock:( NSString * ( ^ )( int ) )myBlock; 
  
   　　// .m 
  
   　　-(void) testBlock:( NSString * ( ^ )( int ) )myBlock 
  
   　　{ 
  
   NSLog(@ 
   "Block returned: %@" 
   , myBlock(7) ); 
  
   　　}

因为Objective-C是强制类型语言，因此做为函数参数的block也必需要指定返回值的类型，以及相关参数类型。

2.3 闭包性

上文说过，block实际是Objc对闭包的实现。

咱们来看看下面代码：

 
   　　#import void logBlock( int ( ^ theBlock )( void ) ) 
  
   　　{ 
  
   NSLog( @ 
   "Closure var X: %i" 
   , theBlock() ); 
  
   　　} 
  
   　　int main( void ) 
  
   　　{ 
  
   NSAutoreleasePool * pool; 
  
   int ( ^ myBlock )( void ); 
  
   int x; 
  
   pool = [ [ NSAutoreleasePool alloc ] init ]; 
  
   x = 42; 
  
   myBlock = ^( void ) 
  
   { 
  
   return  
   x; 
  
   }; 
  
   logBlock( myBlock ); 
  
   [ pool release ];　　 
  
   return  
   EXIT_SUCCESS; 
  
   　　}

上面的代码在main函数中声明了一个整型，并赋值42，另外还声明了一个block，该block会将42返回。而后将block传递给logBlock函数，该函数会显示出返回的值42。即便是在函数logBlock中执行block，而block又声明在main函数中，可是block仍然能够访问到x变量，并将这个值返回。

注意：block一样能够访问全局变量，即便是static。

2.4 block中变量的复制与修改

对于block外的变量引用，block默认是将其复制到其数据结构中来实现访问的.

经过block进行闭包的变量是const的。也就是说不能在block中直接修改这些变量。来看看当block试着增长x的值时，会发生什么：

　　myBlock = ^( void )

　　{

　　 x++;

　　 return x;

　　};

编译器会报错，代表在block中变量x是只读的。

有时候确实须要在block中处理变量，怎么办？别着急，咱们能够用__block关键字来声明变量，这样就能够在block中修改变量了。

基于以前的代码，给x变量添加__block关键字，以下：

　　__block int x;

对于用__block修饰的外部变量引用，block是复制其引用地址来实现访问的.

3.编译器中的block

3.1 block的数据结构定义

上图这个结构是在栈中的结构，咱们来看看对应的结构体定义：

 
   　　struct Block_descriptor { 
  
   unsigned long int reserved; 
  
   unsigned long int size; 
  
   void (*copy)(void *dst, void *src); 
  
   void (*dispose)(void *); 
  
   　　}; 
  
   　　struct Block_layout { 
  
   void *isa; 
  
   int flags; 
  
   int reserved; 
  
   void (*invoke)(void *, ...); 
  
   struct Block_descriptor *descriptor; 
  
   /* Imported variables. */　　 
  
   　　};

从上面代码看出，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.2 block的类型

block有几种不一样的类型，每种类型都有对应的类，上述中isa指针就是指向这个类。这里列出常见的三种类型：

_NSConcreteGlobalBlock：全局的静态block，不会访问任何外部变量，不会涉及到任何拷贝，好比一个空的block。例如：

 
   　　#include int main() 
  
   　　{ 
  
   ^{ printf( 
   "Hello, World!\n" 
   ); } (); 
  
   return  
   0; 
  
   　　}

_NSConcreteStackBlock：保存在栈中的block，当函数返回时被销毁。例如：

　　#include int main()

　　{

　　 char a = 'A' ;

　　 ^{ printf( "%c\n" ,a); } ();

　　 return 0;

　　}

_NSConcreteMallocBlock：保存在堆中的block，当引用计数为0时被销毁。该类型的block都是由_NSConcreteStackBlock类型的block从栈中复制到堆中造成的。例以下面代码中，在exampleB_addBlockToArray方法中的block仍是_NSConcreteStackBlock类型的，在exampleB方法中就被复制到了堆中，成为_NSConcreteMallocBlock类型的block：

 
   　　void exampleB_addBlockToArray(NSMutableArray *array) { 
  
   char b =  
   'B' 
   ;　　 
  
   [array addObject:^{ 
  
   printf( 
   "%c\n" 
   , b);　　 
  
   }];　　 
  
   　　} 
  
   　　void exampleB() { 
  
   NSMutableArray *array = [NSMutableArray array]; 
  
   exampleB_addBlockToArray(array); 
  
   void (^block)() = [array objectAtIndex:0]; 
  
   block(); 
  
   　　}

总结：

_NSConcreteGlobalBlock类型的block要么是空block，要么是不访问任何外部变量的block。它既不在栈中，也不在堆中，我理解为它可能在内存的全局区。

_NSConcreteStackBlock类型的block有闭包行为，也就是有访问外部变量，而且该block只且只有有一次执行，由于栈中的空间是可重复使用的，因此当栈中的block执行一次以后就被清除出栈了，因此没法屡次使用。

_NSConcreteMallocBlock类型的block有闭包行为，而且该block须要被屡次执行。当须要屡次执行时，就会把该block从栈中复制到堆中，供以屡次执行。

3.3 编译器如何编译

　　#import typedef void(^BlockA)(void);

　　__attribute__((noinline))　　

　　void runBlockA(BlockA block) {

　　 block();

　　}

　　void doBlockA() {

　　 BlockA block = ^{

　　 // Empty block

　　 };

　　 runBlockA(block);

　　}

上面的代码定义了一个名为BlockA的block类型，该block在函数doBlockA中实现，并将其做为函数runBlockA的参数，最后在函数doBlockA中调用函数runBloackA。

注意：若是block的建立和调用都在一个函数里面，那么优化器(optimiser)可能会对代码作优化处理，从而致使咱们看不到编译器中的一些操做，因此用__attribute__((noinline))给函数runBlockA添加noinline，这样优化器就不会在doBlockA函数中对runBlockA的调用作内联优化处理。

咱们来看看编译器作的工做内容：

 
   　　#import __attribute__((noinline)) 
  
   　　void runBlockA(struct Block_layout *block) { 
  
   block->invoke(); 
  
   　　}　　 
  
   　　void block_invoke(struct Block_layout *block) { 
  
   // Empty block function 
  
   　　} 
  
   　　void doBlockA() { 
  
   struct Block_descriptor descriptor; 
  
   descriptor->reserved = 0; 
  
   descriptor->size = 20; 
  
   descriptor->copy = NULL; 
  
   descriptor->dispose = NULL; 
  
   struct Block_layout block; 
  
   block->isa = _NSConcreteGlobalBlock; 
  
   block->flags = 12345678; 
  
   block->reserved = 0; 
  
   block->invoke = block_invoke; 
  
   block->descriptor = descriptor; 
  
   runBlockA(&block); 
  
   　　}

上面的代码结合block的数据结构定义，咱们能很容易得理解编译器内部对block的工做内容。

3.4 copy()和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中拷贝的变量等。