Objective-C的Block
Apple在C，Objective-C和C++中扩充了Block这种文法的，并且在GCC4.2中进行了支持。现在我们可以在Mac 10.6和iOS 4中使用。如果是Mac 10.6 或 iOS 4.0 之前的平台，据说可以用 http://code.google.com/p/plblocks/这个项目来支持Block语法。
Apple在 Snow Leopard中所用到的Grand Central Dispatch(GCD)就是基于Blocks实现的。Grand Central Dispatch是苹果开发的工具，目的是帮助开发者更容易的利用多核处理器的并行处理功能。关于Blocks以及GCD在苹果官方的介绍，请见：Introducing Blocks and Grand Central Dispatch。
你可以把它理解为函数指针，匿名函数，闭包，lambda表达式，这里暂且用块对象来表述，因为它们之间还是有些许不同的。
块对象
块对象是C级别的文法，同时也是一种运行时特征，即它允许您把函数表达式组合在一起，组合结果可作为参数传递也可保存，还可供多个线程使用。块对象的函数表达式可引用或持有局部变量。在其他的语言环境中，块对象有时也被称为closure或者lambda。如果您需创建可如数值般传递的工作单元（即代码段），则可使用块对象，它可为您提供更多的编程灵活性和更强大的功能。如需编写回调函数或对某个群体的所有项执行某种操作，也可使用块对象。
l 声明一个块
如果以内联方式使用块对象，则无需声明。块对象声明语法与函数指针声明语法相似，但是块对象应使用脱字符(^)而非星号指针 (*)。下面的代码声明一个aBlock变量，它标识一个需传入三个参数并具有float返回值的块。
float (^aBlock)(const int*, int, float);
l 创建一个块
块使用脱字符(^)作为起始标志，使用分号作为结束标志。下面的例子声明一个简单块，并且将其赋给之前声明的block变量（oneFrom）。
int (^oneFrom)(int);
oneFrom = ^(int anInt) {
    return anInt - 1;
};
结尾处的分号是标准C的行结束标志。如果未显式声明块表达式的返回值，则编译器会根据块内容自动进行推导。
l 块可变变量
如果某个局部变量使用__block存储修饰符，则表示块应使用此变量的引用，并可更改它的值。对变量的任何改变都只在块的语法作用域内部，以及该作用域中定义的其它块中起作用。
块对象的特性
Blocks比C++0x中的lambda表达式更强的一点是，它可以是个数组类型：
int main(void)
{
    void (^p[2])(void) = { ^(void){ puts("Hello, world!"); }, ^(void){ puts("Goodbye!"); } };
    p[0](), p[1]();
}
这里p的类型为void(^[2])(void)，表示含有2个void(^)(void)块引用元素的变量。下面谈谈函数块对其外部临时变量的可访问情况。
static int global = 100;
int main(void)
{
    int local = 200;
    void (^p)(void) = ^(void){ printf("The answer is: %dn", global + local); };
    p();
}
对于FP比较熟悉的朋友可能会想到，如果一个外部变量能够随随便便被一个函数块修改的话，那么对于其本身的副作用仍然无法进行方便地多核并行编程。那么我们不妨试试看吧：
static int global = 100;
int main(void)
{
    int local = 200;
    void (^p)(void) = ^(void){
        printf("The answer is: %dn", global + local);
        global++;
        local--;    // compiling error:error: decrement of read-only variable \'local\'
    };
    p();
printf("After modified, global is: %d and local is %dn", global, local);
}
对于全局变量可以进行修改，但是对于main函数中的局部变量则不行。如果对local修改则无法通过编译。很显然，Blocks对此已经有了相应的机制。 那么我们如何能够对local进行修改呢？
static int global = 100;
int main(void)
{
    __block int local = 200;
    static int s = 10;
   
    void (^p)(void) = ^(void){
        printf("The answer is: %dn", global + local);
        global++;
        s++;
        local--;
    };
    p();
    printf("After modified, global is: %d and local is %d and s is: %dn", global, local, s);
}
这里引入了一个新的关键字 ——__block，用此声明一个局部变量可以被函数块修改。
Block是否可以递归
如果要使Blocks能够递归，那么在函数块中必须能够引用函数块的入口地址。我做了一些尝试，当函数块引用是全局的或static的，即函数块内所引用的函数 块引用变量的值在初始时就已经确定的，那么可以使用递归。
int main(void)
{
    void (^p)(int) = 0;
    static void (^ const blocks)(int) = ^(int i){ if(i > 0){ puts("Hello, world!"); blocks(i - 1); } };
    p = blocks;
    p(2);
}
如果在上述代码中将blocks前的static去掉，那么在运行时就会出错，因为blocks在被函数块引用时是未初始化值，所以调用它的话就访问了无效地址，或者所要执行的指令是未定义的。
Blocks结合泛型
由于泛型能够使我们更高效、合理地管理好自己的代码，同时也为部件化提供了许多便利之处。那么Blocks与泛型结合会产生什么新元素呢？
我们先举一个简单例子：
#import <Foundation/Foundation.h>
 
template <void pBlock(void)>
void BlockTest(void)
{
    pBlock();
}
 
void Hi(void)
{
    NSLog(@"Hi, there!");
}
 
int main(int argc, const char* argv[])
{
    BlockTest<Hi>();
}
上述代码中尚未出现Blocks，但是我们可以看到，一般的外部函数能够作为模板参数。那么Blocks是否可以这么做呢？我们不妨尝试一下：
#import <Foundation/Foundation.h>
 
template <void (^pBlock)(void)>
void BlockTest(void)
{
    pBlock();
}
 
int main(int argc, const char* argv[])
{
    BlockTest<^(void) { NSLog(@"Hi, there!"); }>();
}
编译时会在第11行出现error: no matching function for call to \'BlockTest()\'。C++标准中明确指出，模板参数必须为常量表达式，如果是函数的话必须是带有外部连接（即external-linkage）的函数指针。而Blocks表达式首先 就不是一个常量表达式，然后它也没有外部连接。我们下面看第二个例子：
#import <Foundation/Foundation.h>
 
template <typename T>
void BlockTest(void (&pBlock)(T))
{
    pBlock(T());
}
 
static void Hi(int a)
{
    NSLog(@"The value is: %dn", a);
}
 
int main(int argc, const char* argv[])
{
    BlockTest(Hi);
}
上述代码中使用了函数引用作为函数参数，然后由实参类型演绎出模板类型。这段代码将能正常地通过编译、连接并正常运行。那么我们下面再看一看 Blocks是否具有这个泛型特性：
#import <Foundation/Foundation.h>
 
template <typename T>
void BlockTest(void (^pBlock)(T))
{
    pBlock(T());
}
 
int main(int argc, const char* argv[])
{
    BlockTest(^(int a) { NSLog(@"The value is: %dn", a); });
}
编译后出现 error: no matching function for call to \'BlockTest(void (^)(int))\'。即使显式地将<int>模板实参加上也没用。也就是说Blocks的参数类型包括返回类型不能是一个泛型。我们再看第三个例子：
#import <Foundation/Foundation.h>
#include <iostream>
#include <typeinfo>
using namespace std;
 
template <typename T>
void BlockTest(T pBlock)
{
    pBlock();
    cout << "The type is: " << typeid(T).name() << endl;
}
 
static void Hi(void)
{
    NSLog(@"Hi, there!");
}
 
int main(int argc, const char* argv[])
{
 BlockTest(Hi);
}
这段代码展示了整个函数指针类型演绎出模板实参。对于目前已被很多编译器所实现的Lambda表达式，这是与泛型挂钩的唯一桥梁，那么Blocks是否具备这个特性呢？
#import <Foundation/Foundation.h>
#include <iostream>
#include <typeinfo>
using namespace std;
 
template <typename T>
void BlockTest(T pBlock)
{
    pBlock();
    cout << "The type is: " << typeid(T).name() << endl;
}
 
int main(int argc, const char* argv[])
{
    BlockTest(^(void) { NSLog(@"Hi, there!"); });
}
恭喜，我们成功了。这段代码能够正常编译和运行。各位可以自己看看输出结果。其中，类型信息是被压缩过的：F表示函数，P表示指针，v表示void类型。Blocks 与C++0x中的lambda表达式一样，必须作为一个完整的类型。对其类型做拆分进行泛型化是非法的。由于C++0x的Lambda表达式的具体类型不对程序员开放，因此它即不能作为模板形参亦无法作为模板函数的形参，但是它可以在模板函数内使用泛型。
#include <iostream>
using namespace std;
 
template <typename T>
void LambdaTest(T)
{
    T a = 100;
    auto ref = [a](const T& b) -> T { return a + b; };
    cout << "The value is: " << ref(200) << endl;
}
int main(void)
{
    LambdaTest((short)0);
}
上述代码可以在VS2010以及Intel C++ Compiler11.0通过编译并正常运行。然而比较奇怪的是Blocks在模板函数内的表现就非常不好——
template <typename T>
void BlockTest(void)
{
    void (^pBlocks)(void) = ^{};
}
int main(int argc, const char* argv[])
{
    BlockTest<void>();
}
上面这段代码中，模板函数BlockTest中pBlocks根本就没用泛型，也无法通过编译，而且报的错误是internal error: segmentation fault。而只有下面这种情况才能通过编译，但实际上是没有任何意义的：
#import <Foundation/Foundation.h>
template <typename T>
void BlockTest(void)
{
    void (^pBlock)(void) = nil;
}
 
int main(int argc, const char* argv[])
{
    BlockTest<void>();
}
可见，Blocks作为Lambda表达式而言已经是非常棒的，但与lambda函数功能相比就稍逊一些，尤其是与泛型结合时，表现得很一般。其实这也是与 Blocks的实现有关的。Blocks仍然像Objective-C的很多特性那样，主要是靠动态实现的，在编译时所花的精力较少。能够在C以及Objective-C中用上Lambda特性也很不错。
小结
Blocks在作用域，内存管理等方面具有自己独特的特性和需要留意的地方，在许多场景也很多实用的功能。虽然有时理解起来有点费劲，但是用好了，相信用好了可以大大提高代码可读性和效率等。

本文出自 “ArthurChen” 博客，请务必保留此出处http://arthurchen.blog.51cto.com/2483760/616735