Objective-C Blocks研究（转）

1. block基础
block声明有点像c语言的函数指针

[代码]c#/cpp/oc代码：

1	int func(int);

2

3	int (*pfunc)(int);

4

5	int func(int p)

6

{

7	printf("%d", p);

8

return p;

9

}

其中func是函数, pfunc是函数指针

函数指针赋值 
pfunc = &func;

函数指针使用
(*pfunc)(100);

block的声明
int (^bfunc)(int);

block的赋值
bfunc = ^(int p){
  printf("%d", p);
  return p;
};

block的使用
bfunc(10);

有些情况下，用户需要在多个地方用到签名相同的block，那么可以用typedef来定义block类型, 如

[代码]c#/cpp/oc代码：

01	typedef int (^MyBlock)(int);

02	MyBlock block1 = ^(int p){

03	printf("%d", p);

04

return p;

05

}

06

07	MyBlock block2 = ^(int p){

08	printf("%d", p * 2);

09	return p * 2;

10

}

2. block对外部变量的使用
对于全局变量，静态变量，类成员变量处理方式是相同的，但对于局部变量，在定义完block之后，它的值就被固定了，即使在block本身被调用之前修改了，在block内部使用的局部变量依然是block被定义时的值

以下是示例代码，其中var1是全局变量, var2是全局静态变量, var3是类的成员变量, var4是函数的局部变量。

[代码]c#/cpp/oc代码：

01	typedef void (^MyBlock)(int);

02

….

03

04

05

var1 = 1;

06	MyBlock block1 = ^(int p)

07

{

08	printf("\nvar1:%d", var1);

09

};

10

11	block1(0);

12

var1 = 2;

13	block1(0);

14

15

var2 = 2;

16	MyBlock block2 = ^(int p)

17

{

18	printf("\nvar2:%d", var2);

19

};

20

21

22	block2(0);

23

var2 = 3;

24	block2(0);

25

26

var3 = 3;

27	MyBlock block3 = ^(int p)

28

{

29	printf("\nvar3:%d", var3);

30

};

31

32	block3(0);

33

var3 = 4;

34	block3(0);

35

36

var4 = 4;

37	MyBlock block4 = ^(int p)

38

{

39	printf("\nvar4:%d", var4);

40

};

41

42

43	block4(0);

44

var4 = 5;

45	block4(0);

这段代码执行的结果是：
var1:1
var1:2
var2:2
var2:3
var3:3
var3:4
var4:4
var4:4

对于全局变量、静态变量和类成员变量，block中的代码是可以修改它们的值的。
但对于局部变量，默认情况下block把它当作常量处理，如果需要修改，必须在局部变量定义的地方加上修饰符 __block

3. block和Objective-C对象变量

对于全局变量和静态变量，相比普通变量没有任何特殊的地方。
根据apple的官方文档，对于成员变量和局部变量，在block中引用会引起retainCount的变化。对成员变量的直接引用会使成员变量所在的那个对象retainCount + 1, 对局部变量的引用会使局部变量的retainCount + 1。如果对局部变量使用__block作为修饰符，就可以使局部变量被block引用时不进行retain的操作。

我自己尝试了一下，发现有一点apple的文档里没有写清楚，block对成员变量和局部变量引用时并不一定会引起retainCount的变化，以下是我的测试代码。

obj3是成员变量

[代码]c#/cpp/oc代码：

1	obj3 = [[TestObjectalloc] init];

2	printf("\nself retain count:%d", [selfretainCount]);

3	MyBlock block6 = ^(int p)

4

{

5	printf("\nself retain count:%d", [selfretainCount]);

6	printf("\nobj retain count:%d", [obj3retainCount]);

7

};

8	block6(0);

9	printf("\nself retain count:%d", [selfretainCount]);

输出结果:
self retain count:1
self retain count:1
obj retain count:1
self retain count:1

[代码]c#/cpp/oc代码：

01	obj3 = [[TestObjectalloc] init];

02	printf("\nself retain count:%d", [selfretainCount]);

03	MyBlock block7 = ^(int p)

04

{

05	printf("\nself retain count:%d", [selfretainCount]);

06	printf("\nobj retain count:%d", [obj3retainCount]);

07

};

08	MyBlock block77 = Block_copy(block7);

09	block7(0); //或者 block77(0);

10	printf("\nself retain count:%d", [selfretainCount]);

11	Block_release(block77);

12	printf("\nself retain count:%d", [selfretainCount]);

self retain count:1
self retain count:2
obj retain count:1
self retain count:2
self retain count:1

obj4是局部变量

[代码]c#/cpp/oc代码：

01	TestObject *obj4 = [[TestObjectalloc] initWithValue:4];

02	MyBlock block8 = ^(int p)

03

{

04	printf("\nobj4 retain count:%d", [obj4 retainCount]);

05

};

06	MyBlock block88 = Block_copy(block8);

07	block88(0);

08	printf("\nobj4 retain count:%d", [obj4 retainCount]);

09	Block_release(block88);

10	printf("\nobj4 retain count:%d", [obj4 retainCount]);

  

 

obj4 retain count:2
obj4 retain count:2
obj4 retain count:1

[代码]c#/cpp/oc代码：

01	__block TestObject *obj5 = [[TestObjectalloc] initWithValue:5];

02	MyBlock block9 = ^(int p)

03

{

04	printf("\nobj5 retain count:%d", [obj5 retainCount]);

05

};

06	MyBlock block99 = Block_copy(block9);

07	block99(0);

08	printf("\nobj5 retain count:%d", [obj5 retainCount]);

09	Block_release(block99);

10	printf("\nobj5 retain count:%d", [obj5 retainCount]);

obj5 retain count:1
obj5 retain count:1
obj5 retain count:1

结论是在一个方法内的block对对象的引用不会引起retainCount变化，但是调用Block_copy以后，retainCount会变化，但是block执行完以后引用对象的retainCount不会增加，需要调用Block_release才能释放之前Block_copy引起的retainCount增加。

 

//////////////////////////////////////////////

//////////////////////////////////////////////

//////////////////////////////////////////////

 

Block

Apple 在C, Objective-C, C++加上Block這個延申用法。目前只有Mac 10.6 和iOS 4有支援。Block是由一堆可執行的程式組成，也可以稱做沒有名字的Function (Anonymous function)。如果是Mac 10.6 或 iOS 4.0 之前的平台可以利用 http://code.google.com/p/plblocks/ 這個project得以支援Block語法。
Apple有一個叫做GCD(Grand Central Dispach)的新功能，用在同步處理(concurrency)的環境下有更好的效率。Block語法產生的動機就是來自於GCD，用Block包好 一個工作量交給GCD，GCD有一個宏觀的視野可以來分配CPU，GPU，Memory的來下最好的決定。

Block 簡介

Block其實行為和Function很像，最大的差別是在可以存取同一個Scope的變數值。
Block 實體會長成這樣

^(傳入參數列) {行為主體};

Block實體開頭是"^"，接著是由小括號所包起來的參數列(比如 int a, int b, float c)，行為的主體由大括號包起來，專有名詞叫做block literal。行為主體可以用return回傳值，型別會被compiler自動辦識出來。如果沒有參數列要這樣寫(void)。
看個列子

[代码]c#/cpp/oc代码：

1	^(int a) {return a*a;};

這是代表Block會回傳輸入值的平方值(int a 就是參數列，return a*a; 就是行為主體)。記得主體裡最後要加";"因為是敘述，而整個{}最後也要要加";"因為Block是個物件實體。
用法就是

[代码]c#/cpp/oc代码：

1	int result = ^(int a) {return a*a;} (5);

很怪吧。後面小括號裡的5 會被當成a的輸入值然後經由Block輸出5*5 = 25指定給result這個變數。
有沒有簡單一點的方法不然每次都要寫這麼長？有。接下來要介紹一個叫Block Pointer的東西來簡化我們的寫法。
Block Pointer是這樣宣告的

回傳值 (^名字) (參數列);

直接來看一個列子

[代码]c#/cpp/oc代码：

1	int (^square) (int);

Block

Apple 在C, Objective-C, C++加上Block這個延申用法。目前只有Mac 10.6 和iOS 4有支援。Block是由一堆可執行的程式組成，也可以稱做沒有名字的Function (Anonymous function)。如果是Mac 10.6 或 iOS 4.0 之前的平台可以利用 http://code.google.com/p/plblocks/ 這個project得以支援Block語法。
Apple有一個叫做GCD(Grand Central Dispach)的新功能，用在同步處理(concurrency)的環境下有更好的效率。Block語法產生的動機就是來自於GCD，用Block包好 一個工作量交給GCD，GCD有一個宏觀的視野可以來分配CPU，GPU，Memory的來下最好的決定。

Block 簡介

Block其實行為和Function很像，最大的差別是在可以存取同一個Scope的變數值。
Block 實體會長成這樣

^(傳入參數列) {行為主體};

Block實體開頭是"^"，接著是由小括號所包起來的參數列(比如 int a, int b, float c)，行為的主體由大括號包起來，專有名詞叫做block literal。行為主體可以用return回傳值，型別會被compiler自動辦識出來。如果沒有參數列要這樣寫(void)。
看個列子

^(int a) {return a*a;};

這是代表Block會回傳輸入值的平方值(int a 就是參數列，return a*a; 就是行為主體)。記得主體裡最後要加";"因為是敘述，而整個{}最後也要要加";"因為Block是個物件實體。
用法就是

int result = ^(int a) {return a*a;} (5);

很怪吧。後面小括號裡的5 會被當成a的輸入值然後經由Block輸出5*5 = 25指定給result這個變數。
有沒有簡單一點的方法不然每次都要寫這麼長？有。接下來要介紹一個叫Block Pointer的東西來簡化我們的寫法。
Block Pointer是這樣宣告的

回傳值 (^名字) (參數列);

直接來看一個列子

int (^square) (int);

// 有一個叫square的Block Pointer，其所指向的Block是有一個int 輸入和 int 輸出

square = ^(int a ) {return a*a ;}; // 將剛剛Block 實體指定給 square

使用Block Pointer的例子

int result = square(5); // 感覺上不就是funtion的用法嗎？

也可以把Block Pointer當成參數傳給一個function，比如說

void myFuction( int (^mySquare) (int) ); // function 的宣告，

傳入一個有一個int輸入和int輸出的Block 型別的參數
呼叫這個myFunction的時候就是這樣呼叫

int (^mySqaure) (int) = ^(int a) {return a*a;};

// 先給好一個有實體的block pointer叫mySquare

myFunction( mySqaure ) ; //把mySquare這個block pointer給myFunction這個function

或是不用block pointer 直接給一個block 實體，就這樣寫

myFunction( ^(int a) {return a*a} ) ;

當成Objective-C method 的傳入值的話都是要把型別寫在變數前面然後加上小括號，因些應該就要這樣寫

-(void) objcMethod:( int (^) (int) ) square; // square 變數的型別是 int (^) (int)

讀文至此是不是對Block有基本的認識？ 接下來我們要談談Block相關的行為和特色
首先是來看一下在Block裡面存取外部變數的方法

存取變數

1. 可以讀取和Block pointer同一個scope的變數值：

{
int outA = 8;
int (^myPtr) (int) = ^(int a) {return outA+a;};
// block 裡面可以讀同一個scope的outA的值
int result = myPtr(3); // result is 11
}

我們再來看一個很有趣的例子

{
int outA = 8;
int (^myPtr) (int) = ^(int a) {return outA+a;};
// block 裡面可以讀同一個scope的outA的值
outA = 5; // 在呼叫myPtr之前改變outA的值
int result = myPtr(3); // result 的值還是 11並不是 8
}

事實上呢，myPtr在其主體用到outA這個變數值的時候是做了一個copy的動作把outA的值copy下來。所以之後outA即使換了新的值對於myPtr裡copy的值是沒有影響到的。
要注意的是，這個指的值是變數的值，如果這個變數的值是一個記憶體的位置，換句話說，這個變數是個pointer的話，它指到的值是可以在block裡被改變的。

[代码]c#/cpp/oc代码：

1

{

2	NSMutableArray * mutableArray = [NSMutableArray arrayWithObjects:@"one",@"two",@"three",nil];

3	int result = ^(int a) { [mutableArray removeLastObject]; return a*a;} (5);

4

5	NSLog(@"test array %@", mutableArray);

6

7

}

 

 

原本mutableArray的值是{@"one",@"two",@"three"}在block裡被更改mutableArray所指向的物件後，mutableArray的值就會被成{@"one",@"two"}
2. 直接存取static 的變數 

{
static int outA = 8;
int (^myPtr) (int) = ^(int a) {return outA+a;};
// block 裡面可以讀同一個scope的outA的值
outA = 5; // 在呼叫myPtr之前改變outA的值
int result = myPtr(3); // result 的值是 8，因為outA是個static 變數會直接反應其值
}

甚至可以在block裡面直接改變outA的值比如這樣寫

{
static int outA = 8;
int (^myPtr) (int) = ^(int a) { outA= 5; return outA+a;};
// block 裡面改變outA的值
int result = myPtr(3); // result 的值是 8，因為outA是個static 變數會直接反應其值

}

3. Block Variable
在某個變數前面如果加上修飾字__block 的話(注意block前有兩個下底線)，這個變數又稱為block variable。那麼在block裡就可以任意修改此變數值，變數值的改變也可以知道。

[代码]c#/cpp/oc代码：

1

{

2	__block int num = 5;

3

4	int (^myPtr) (int) = ^(int a) { return num++;};

5	int (^myPtr2) (int) = ^(int a) { return num++;};

6	int result = myPtr(0);

7	result = myPtr2(0);

8

}

 

 

因為myPtr和myPtr2都有用到num這個block variable，最後result的值就會是7

生命周期和記憶體管理

因為block也是繼承自NSObject，所以其生命周期和記憶體的管理也就非常之重要。
block一開始都是被放到stack裡，換句話說其生命周期隨著method或function結束就會被回收，和一般變數的生命周期一樣。
關於記憶體的管理請遵循這幾個要點
1. block pointer的實體會在method或function結束後就會被清掉
2. 如果要保存block pointer的實體要用-copy指令，這樣block pointer就會被放到heap裡
2.1 block 主體裡用到的block variable 也會被搬到heap 而有新的記憶體位置，且一並更新有用到這個block variable 的block都指到新的位置
2.2 一般的variable值會被copy 
2.3 如果主體裡用到的variable是object的話，此object會被retain, block release時也會被release
2.4 __block variable 裡用到的object是不會被retain的

首先來看一下這個例子

[代码]c#/cpp/oc代码：

01	typedef int (^MyBlock)(int);

02

03	MyBlock genBlock();

04

05	int main(){

06	MyBlock outBlock = genBlock();

07	int result = outBlock(5);

08

09	NSLog(@"result is %d",[outBlock retainCount] ); // segmentation fault

10	NSLog(@"result is %d",result );

11

12	return 0 ;

13

}

14	MyBlock genBlock() {

15	int a = 3;

16	MyBlock inBlock = ^(int n) {

17	return n*a;

18

};

19	return inBlock ;

20

}

 

此程式由genBlock裡產生的block再指定給main function的outBlock變數，執行這個程式會得到
Segmentation fault
(註：有時候把 genBlock裡的a 去掉就可以跑出結果的情形，這是系統cache住記憶體，並不是inBlock真得一直存在，久了還是會被回收，千萬不要以為是對的寫法)
表示我們用到了不該用的記憶體，在這個例子的情況下是在genBlock裡的inBlock變數在return的時候就被回收了，outBlock無法有一個合法的記憶體位置-retainCount就沒意義了。
如果這個時候需要保留inBlock的值就要用-copy指令，將genBlock改成

[代码]c#/cpp/oc代码：

1	MyBlock genBlock() {

2	int a = 3;

3	MyBlock inBlock = ^(int n) {

4	return n*a;

5

};

6	return [inBlock copy] ;

7

}

 

 

這樣[inBlock copy]的回傳值就會被放到heap，就可以一直使用(記得要release)
執行結果是
result is 1
result is 15

再次提醒要記得release outBlock。
如果一回傳[inBlock copy]的值就不再需要的時候可以這樣寫

[代码]c#/cpp/oc代码：

1	MyBlock genBlock() {

2	int a = 3;

3	MyBlock inBlock = ^(int n) {

4	return n*a;

5

};

6	return [[inBlock copy] autorelease] ;

7

}

 

-copy指令是為了要把block 從stack搬到heap，autorelease是為了平衝retainCount加到autorelease oop ，回傳之後等到事件結束就清掉。

接下來是block存取到的local variable是個物件的型別，然後做copy 指令時

[代码]c#/cpp/oc代码：

1	MyBlock genBlock() {

2	int a = 3;

3	NSMutableString * myString = [NSMutableString string];

4	MyBlock inBlock = ^(int n) {

5	NSLog(@"retain count of string %d",[myString retainCount]);

6	return n*a;

7

};

8	return [inBlock copy] ;

9

}

 

結果會印出
retain count of string 2
這個結果和上面2.3提到的一樣，local variable被retain了
那再來試試2.4，在local variable前面加上__block

[代码]c#/cpp/oc代码：

1	MyBlock genBlock() {

2	int a = 3;

3	__block NSMutableString * myString = [NSMutableString string];

4	MyBlock inBlock = ^(int n) {

5	NSLog(@"retain count of string %d",[myString retainCount]);

6	return n*a;

7

};

8	return [inBlock copy] ;

9

}

 

執行的結果就是會
retain count of string 1

Block Copying注意事項

如果在Class method裡面做copying block動作的話
1. 在Block裡如果有直接存取到self，則self會被retain
2. 在Block裡如果取存到instance variable (無論直接或是從accessor)，則self會被retain
3. 取存到local variable所擁有的object時，這個object會被retain

讓我們來看一個自訂的Class

[代码]c#/cpp/oc代码：

01	@interface MyObject : NSObject {

02	NSString * title;

03	void (^myLog) (NSString * deco);

04

}

05

06	-(void) logName;

07

@end

08

09	@implementation MyObject

10	-(id) initWithTitle:(NSString * ) newTitle{

11	if(self = [super init]){

12	title = newTitle;

13	myLog = [^(NSString * deco) { NSLog(@"%@%@%@",deco, title, deco );} copy];

14

}

15	return self;

16

}

17

18	-(void) logName{

19

20	myLog(@"==");

21

}

22

23	-(void ) dealloc{

24

25	[myLog release];

26	[title release];

27	[super dealloc];

28

}

29

@end

 

在main 裡使用如下

[代码]c#/cpp/oc代码：

1	MyObject * mObj = [[MyObject alloc] initWithTitle:@"Car"];

2	NSLog(@"retainCount of MyObject is %d",[mObj retainCount] );

3	[mObj logName];

其執行的結果為
retainCount of MyObject is 2
==Car==
因為在MyObject的建構子裡myLog這個block pointer用了title這個instance variable然後就會retain self也就是MyObject的物件。
盡量不要這樣寫，會造成retain cycle，改善的方法是把建構子改成這樣

[代码]c#/cpp/oc代码：

1	-(id) initWithTitle:(NSString * ) newTitle{

2	if(self = [super init]){

3	title = newTitle;

4	myLog = [^(NSString * deco) { NSLog(@"%@%@%@",deco, newTitle, deco );} copy];

5

}

6	return self;

7

}

在Block主體裡用newTitle這個變數而不是title。這樣self就不會被retain了。
最後談一個小陷井

[代码]c#/cpp/oc代码：

1	void (^myLog) (void);

2	BOOL result ;

3	if(result)

4	myLog = ^ {NSLog(@"YES");};

5

6

else

7	myLog = ^ {NSLog(@"NO");};

8

9

myLog();

這樣很可能就會當掉了，因為myLog 實體在if 或是else結束後就被清掉了。要記得。

要用copy來解決這個問題，但要記得release。