浅析OC中的block
一、Block
带有 自动变量/局部变量 的匿名函数叫做 block ，又叫做 匿名函数 、代码块 。
完整形式的 Block 语法与一般的 **C语言 **函数定义相比，仅有两点不同：
- 没有函数名 不含函数名是因为其为匿名函数。
- 带有 “ ^ ” 返回值类型前带有 ^ ，由于 OSX，iOS 应用程序中将大量使用 Block 因此插入该记号便于查找。
Block语法
- 无参无返
//1，无参数，无返回值，声明和定义
void(^MyBlockOne)(void) = ^(void){
NSLog(@"无参数，无返回值");
};
MyBlockOne();//block的调用
- 有参无返
//2，有参数，无返回值，声明和定义
void(^MyblockTwo)(int a) = ^(int a){
NSLog(@"@ = %d我就是block，有参数，无返回值",a);
};
MyblockTwo(100);
- 有参有返
//3，有参数，有返回值
int(^MyBlockThree)(int,int) = ^(int a,int b){
NSLog(@"%d我就是block，有参数，有返回值",a + b);returna + b;
};
MyBlockThree(12,56);
- 无参无返
//4，无参数，有返回值
int(^MyblockFour)(void) = ^{NSLog(@"无参数，有返回值");
return45;
};
MyblockFour();
我们使用 “{ }” 限定 Block 的范围，这一点与函数和方法的定义很相似。
类似于使用一个C函数指针, 我们可以声明一个变量来存储 Block ：
void (^simpleBlock)(void);
//同样也可以这样来为block变量赋值
simpleBlock = ^{
NSLog(@"This is a block");
};
需要注意的是: Block 赋值和其它类型的变量赋值一样, 需要以 ; 结尾。
我们也可以在声明变量的同时为其赋值：
void (^simpleBlock)(void) = ^{
NSLog(@"This is a block");
};
//之后我们就可以像这样调用Block了:
simpleBlock();
带有参数和返回值的Block
和函数和方法类似，Block 可以接收参数或者有返回值。
假如我们需要声明一个两个 double 类型相乘并返回结果的 Block：
double (^multiplyTwoValues)(double, double);
//对应的 block 实现如下
^ (double firstValue, double secondValue) {
return firstValue * secondValue;
}
//在这个例子中, 返回值可以通过return 表达式推断出来. 当然我们也可以像这样显式声明返回值类型:
^ double (double firstValue, double secondValue) {
return firstValue * secondValue;
}
在我们声明并定义了 Block 之后，我们可以就像调用函数一样，调用 Block 了：
double (^multiplyTwoValues)(double, double) =
^(double firstValue, double secondValue) {
return firstValue * secondValue;
};
double result = multiplyTwoValues(2,4);
NSLog(@"The result is %f", result);
Block捕获上下文信息
Block 不仅仅包含了可执行的代码片段，Block 也有能力从临近作用域捕获上下文信息。
如果我们定义了一个方法内部的 Block ，Block 可以捕获方法内作用域的上下文信息：
- (void)testMethod {
int anInteger = 42;
void (^testBlock)(void) = ^{
NSLog(@"Integer is: %i", anInteger);
};
testBlock();
}
在这个例子中，anInteger 在 block 外部声明，但是在 block 定义时, 它的值被 block “捕获” 了。
这里捕获的仅仅是值， 当我们在 block，的定义和 block 的调用之间修改 anInteger 的值时：
int anInteger = 42;
void (^testBlock)(void) = ^{
NSLog(@"Integer is: %i", anInteger);
};
anInteger = 84;
testBlock();
testBlock( ) 的输出并不会被 anInteger 的新值影响，因为我们只捕获了值，因此输出如下：
Integer is: 42
这也意味着 Block 不能改变捕获变量的原值。
__block的使用
如果我们需要从 block 内部改变外部捕获变量的值时, 我们可以在要修改的外部变量声明中使用 __block 存储类型修饰符。使用了 __block 修饰符的变量的储存空间，被它本身的作用域与引用了它的 __block 的作用域所共享：
__block int anInteger = 42;
void (^testBlock)(void) = ^{
NSLog(@"Integer is: %i", anInteger);
};
anInteger = 84;
testBlock();
由于使用了**__block** 修饰 anInteger ，因此 anInteger 的存储和 block 的声明共享。因此输出如下：
Integer is: 84
这也意味着在 Block 中可以修改原值：
__block int anInteger = 42;
void (^testBlock)(void) = ^{
NSLog(@"Integer is: %i", anInteger);
anInteger = 100;
};
testBlock();
NSLog(@"Value of original variable is now: %i", anInteger);
此时输出如下：
Integer is: 42
Value of original variable is now: 100
函数指针和指针函数
block 本质上是一个函数指针。
指针函数与函数指针表示方法的不同，不要混淆。最简单的辨别方式就是看函数名前面的指针 * 号有没有被括号（ ）包含，如果被包含就是函数指针，反之则是指针函数。
主要的区别是一个是指针变量，一个是函数。
1.指针函数
带指针的函数，即本质是一个函数。函数返回类型是某一类型的指针。
**类型标识符 函数名(参数表) int f(x，y);
首先它是一个函数，只不过这个函数的返回值是一个地址值。指针函数一定有函数返回值，而且在主调函数中，函数返回值必须赋给同类型的指针变量。
float *fun();
float *p;
p = fun( );
当一个函数声明其返回值为一个指针时，实际上就是返回一个地址给调用函数，以用于需要指针或地址的表达式中。由于返回的是一个地址，所以类型说明符一般都是 int。
int *f(int a, int b);
//上面的函数声明又可以写成如下形式：
int* f(int a, int b);
//让指针标志 * 与int紧贴在一起，而与函数名f间隔开，这样看起来就明了些了，f是函数名，返回值类型是一个int类型的指针。
int *f(int a, int b); // 声明指针函数
int main(int argc, char* argv[])
{
printf("------------------------------ Start\n");
int *p1 = NULL;
printf("The memeory address of p1 = 0x%x \n", p1);
p1 = f(1, 2);
printf("The memeory address of p1 = 0x%x \n", p1);
printf("*p1 = %d \n", *p1);
printf("------------------------------ End\n");
getchar();
return 0;
}
/*指针函数的定义，返回值是指针类型int */
int *f(int a, int b) {
int *p = (int *)malloc(sizeof(int));
printf("The memeory address of p = 0x%x \n", p);
memset(p, 0, sizeof(int));
*p = a + b;
printf("*p = %d \n", *p);
return p;
}
------------------------------ 开始
The memeory address of p1 = 0x0
The memeory address of p = 0x551ed0
*p = 3
The memeory address of p1 = 0x551ed0
*p1 = 3
------------------------------ 结束
通过运行结果，可以看出，指针函数 f 返回的类型是一个指针类型，因为 f 是赋值给 int 类型指针 p1 的，如果不是指针类型，编译就会出错。
所以，指针函数就是返回一个地址给调用者，用于需要地址的情况。
2.函数指针（Block）
指向函数(首地址)的指针变量，即本质是一个指针变量。
函数指针说的就是一个指针，但这个指针指向的函数，不是普通的基本数据类型或者类对象。
指向函数的指针包含了函数的地址，可以通过它来调用函数。
*声明格式：类型说明符 (函数名) (参数)
其实这里不能称为函数名，应该叫做**指针的变量名。这个特殊的指针指向一个返回整型值的函数**。指针的声明必须和它指向函数的声明保持一致。指针名和指针运算符外面的括号改变了默认的运算符优先级。如果没有圆括号，就变成了一个返回整型指针的函数的原型声明。
int (*f)(int a, int b); // 声明函数指针
当然，函数指针的返回值也可以是指针。上面的函数指针定义为一个指向一个返回值为整型，有两个参数并且两个参数的类型都是整型的函数。
下面是利用函数指针分别求两个整数的最大值和最小值的用法:
/* 求最大值，返回值是int类型，返回两个整数中较大的一个*/
int max(int a, int b) {
return a > b ? a : b;
}
/* 求最小值，返回值是int类型，返回两个整数中较小的一个*/
int min(int a, int b) {
return a < b ? a : b;
}
int(*f)(int, int); // 声明函数指针，指向返回值类型为int，有两个参数类型都是int的函数
int main(int argc, _TCHAR* argv[])
{
printf("------------------------------ Start\n");
f = max; // 函数指针f指向求最大值的函数max(将max函数的首地址赋给指针f)
int c = (*f)(1, 2);
printf("The max value is %d \n", c);
f = min; // 函数指针f指向求最小值的函数min(将min函数的首地址赋给指针f)
c = (*f)(1, 2);
printf("The min value is %d \n", c);
printf("------------------------------ End\n");
getchar();
return 0;
}/* 求最大值，返回值是int类型，返回两个整数中较大的一个*/
int max(int a, int b) {
return a > b ? a : b;
}
/* 求最小值，返回值是int类型，返回两个整数中较小的一个*/
int min(int a, int b) {
return a < b ? a : b;
}
int(*f)(int, int); // 声明函数指针，指向返回值类型为int，有两个参数类型都是int的函数
int main(int argc, _TCHAR* argv[])
{
printf("------------------------------ Start\n");
f = max; // 函数指针f指向求最大值的函数max(将max函数的首地址赋给指针f)
int c = (*f)(1, 2);
printf("The max value is %d \n", c);
f = min; // 函数指针f指向求最小值的函数min(将min函数的首地址赋给指针f)
c = (*f)(1, 2);
printf("The min value is %d \n", c);
printf("------------------------------ End\n");
getchar();
return 0;
}
------------------------------ Start
The max value is 2
The min value is 1
------------------------------ End
例如：
void (*fptr)();
把函数的地址赋值给函数指针，可以采用下面两种形式：
fptr=&Function;
fptr=Function;
取地址运算符 & 不是必需的，因为单单一个函数标识符就标号表示了它的地址，如果是函数调用，还必须包含一个圆括号括起来的参数表。
可以采用如下两种方式来通过指针调用函数：
x=(*fptr)();
x=fptr();
第二种格式看上去和函数调用无异。但是有些程序员倾向于使用第一种格式，因为它明确指出是通过指针而非函数名来调用函数的。下面举一个例子：
void (*funcp)();
void FileFunc(), EditFunc();
int main()
{
funcp = FileFunc;
(*funcp)();
funcp = EditFunc;
(*funcp)();
}
void FileFunc()
{
printf("FileFunc\n");
}
void EditFunc()
{
printf("EditFunc\n");
}
//程序输出结果为：
/*FileFunc
EditFunc*/