block的定义和内存

1.2 结构体(Struct)

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

我们来看看结构体的定义:


1

struct tag { member-list } variable-list;

struct:结构体关键字。

tag:结构体标签。

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

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

在一般情况下,tag,member-list,variable-list这三部分至少要出现两个。以下为示例:


1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

// 该结构体拥有3个成员,整型的a,字符型的b,双精度型的c

// 并且为该结构体声明了一个变量s1

// 该结构体没有标明其标签

struct{

    int a;

    char b;

    double c;

} s1;

// 该结构体拥有同样的三个成员

// 并且该结构体标明了标签EXAMPLE

// 该结构体没有声明变量

struct EXAMPLE{

    int a;

    char b;

    double c;

};

//用EXAMPLE标签的结构体,另外声明了变量t1、t2、t3

struct EXAMPLE t1, t2[20], *t3;

以上就是简单结构体的代码示例。结构体的成员可以包含其他结构体,也可以包含指向自己结构体类型的指针。结构体的变量也可以是指针。

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


1

2

3

4

5

6

7

8

9

10

11

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)。


1

2

3

4

5

6

7

8

struct EXAMPLE{

    int a;

    char b;

};

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

int size_example = sizeof( struct EXAMPLE );

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

int offset_b = offsetof( struct EXAMPLE, b );

1.3 闭包(Closure)

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

说的通俗一点,就是闭包允许一个函数访问声明该函数运行上下文中的变量,甚至可以访问不同运行上文中的变量。

我们用脚本语言来看一下:


1

2

3

4

5

6

7

8

9

10

11

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的原型:


1

NSString * ( ^ myBlock )( int );

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

下面来看看block的定义:


1

2

3

4

myBlock = ^( int paramA )

{

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

};

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

注意:一定不要忘记block后面的分号。

定义好block后,就可以像使用标准函数一样使用它了:


1

myBlock(7);

由于block数据类型的语法会降低整个代码的阅读性,所以常使用typedef来定义block类型。例如,下面的代码创建了GetPersonEducationInfo和GetPersonFamilyInfo两个新类型,这样我们就可以在下面的方法中使用更加有语义的数据类型。


1

2

3

4

5

6

7

8

// 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作为参数传递


1

2

3

4

5

6

7

// .h

-(void) testBlock:( NSString * ( ^ )( int ) )myBlock;

// .m

-(void) testBlock:( NSString * ( ^ )( int ) )myBlock

{

    NSLog(@"Block returned: %@", myBlock(7) );

}

由于Objective-C是强制类型语言,所以作为函数参数的block也必须要指定返回值的类型,以及相关参数类型。

2.3 闭包性

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

我们来看看下面代码:


1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

#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的值时,会发生什么:


1

2

3

4

5

myBlock = ^( void )

{

    x++;

    return x;

};

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

有时候确实需要在block中处理变量,怎么办?别着急,我们可以用__block关键字来声明变量,这样就可以在block中修改变量了。

基于之前的代码,给x变量添加__block关键字,如下:


1

__block int x;

对于用__block修饰的外部变量引用,block是复制其引用地址来实现访问的,如下图:

3.编译器中的block

3.1 block的数据结构定义

我们通过大师文章中的一张图来说明:

上图这个结构是在栈中的结构,我们来看看对应的结构体定义:


1

2

3

4

5

6

7

8

9

10

11

12

13

14

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。例如:


1

2

3

4

5

#include int main()

{

    ^{ printf("Hello, World!\n"); } ();

    return 0;

}

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


1

2

3

4

5

6

#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:


1

2

3

4

5

6

7

8

9

10

11

12

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 编译器如何编译

我们通过一个简单的示例来说明:


1

2

3

4

5

6

7

8

9

10

11

#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的调用做内联优化处理。

我们来看看编译器做的工作内容:


1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

#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 = 1342177280;

    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中拷贝的变量等。

时间: 2024-11-08 21:59:23

block的定义和内存的相关文章

IOS开发—block对外部变量的内存管理

block对外部变量的内存管理 代码块在ios中通常用于回调,本文主要介绍block对外部变量的管理机制.我们知道如果要在block中使用block外面的变量,如果该变量是局部变量,就要先将其申明为__block类型.为什么呢?这就涉及到block对外部变量的内存管理. 一.基本数据类型 先看下面测试代码: //局部变量 - (void)localDataTest { int localData = 100; NSLog(@"localData --%p",&localData

block没那么难(三):block和对象的内存管理

本系列博文总结自<Pro Multithreading and Memory Management for iOS and OS X with ARC> 在上一篇文章中,我们讲了很多关于 block 和基础变量的内存管理,接着我们聊聊 block 和对象的内存管理,如 block 经常会碰到的循环引用问题等等. 获取对象 照例先来段代码轻松下,瞧瞧 block 是怎么获取外部对象的 /********************** capturing objects **************

block没那么难(二):block和变量的内存管理

本系列博文总结自<Pro Multithreading and Memory Management for iOS and OS X with ARC> 了解了 block的实现,我们接着来聊聊 block 和变量的内存管理.本文将介绍可写变量.block的内存段.__block变量的内存段等内容,看完本文会对 block 和变量的内存管理有更加清晰的认识. 上篇文章举了个例子,在 block 内获取了一个外部的局部变量,可以读取,但无法进行写入的修改操作.在 C 语言中有三种类型的变量,可在

依旧Block调用引起的内存泄露

@前面的文章讲到,在Block中用到self(self特指UIViewController),需要用__block或者__weak修饰(MRC与ARC的区别),因为Block调用会对其里面的对象引用计数加1,如果你不确定你调用的Block是否会产生循环引用的话,最好用__block或__weak修饰.当然,如果你确定并不会产生循环引用的情况,那你可以放心的self.  self. (~O(∩_∩)O~). @自从知道了block容易产生内存泄露的情况,我在很长的一段时间内,只要用到了block,

Block控制器传值和内存泄漏

(1)Block是C语言的,是一种数据类型.Block出现后,很多代理都会被替代.Block是一种数据类型,是提前准备好的代码段,在需要的时候执行.其实就像调用一个函数一样.准备代码就是{},执行就是(); (2)Block常见问题: *在定义Block时,如果引用了外部变量,会对外部变量做一次copy,记录住定义block时候变量的值,如果后续这个变量变了,也不会影响block的变化,这一瞬间是几就是几 *默认情况下不允许Block修改外部变量,因为拷贝是const拷贝.因为Block可以当一

内联函数,宏定义,内存对齐,类型转换

宏 与 inline的区别 存在的价值,两者都是文本替换,降低程序跳转次数,提高效率 1. define 是预处理命令,无法调试 ,最简单文本替换, inline 是编译期替换,可以调试, 存在参数类型检查 2. 使用inline的时候,函数必须定义 直接定义的函数,自动转化为inline define 怎么访问类的变量.., /////////////////////////////////////////////////////////////////////////////////////

block的定义及使用

(1)最基础的用法案例,我们可以把block理解为一段类似变量一样的可执行函数代码片段: void (^printBlock)(NSString *x); printBlock = ^(NSString* str) { NSLog(@"print:%@", str); }; printBlock(@"hello world!"); (2)由于是变量,所以比方法等可以更灵活的使用,因为可以把block当做一个变量传入到另一个方法. - (void)viewDidLoa

ios影视项目解析 主要为讲block的细节 如果了解了 block的定义等 但是对运用不是很熟悉可以参考本文章

源于github上的影视项目解析 此项目在4app  和  github上都可以下载 项目截图: 此处为程序刚运行界面 程序应有一个discover控制器 找到discover控制器,然后可以根据项目的流程熟悉此项目的原理,从而学习到他们的架构思想 1 - (void)setupTableView 2 { 3 if (!_refreshControl) 4 { 5 _refreshControl = [[UIRefreshControl alloc] initWithFrame:CGRectMa

Swift入坑--block的定义

typealias methodCompletionBlock = (String)->Void