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。如果您需创建可如数值般传递的工作单元(即代码段),则可使用块对象,它可为您提供更多的编程灵活性和更强大的功能。如需编写回调函数或对某个群体的所有项执行某种操作,也可使用块对象。
声明一个块
如果以内联方式使用块对象,则无需声明。块对象声明语法与函数指针声明语法相似,但是块对象应使用脱字符(^)而非星号指针 (*)。下面的代码声明一个aBlock变量,它标识一个需传入三个参数并具有float返回值的块。
float (^aBlock)(const int*, int, float);
创建一个块
块使用脱字符(^)作为起始标志,使用分号作为结束标志。下面的例子声明一个简单块,并且将其赋给之前声明的block变量(oneFrom)。
int (^oneFrom)(int);
oneFrom = ^(int anInt) {
    return anInt - 1;
};
结尾处的分号是标准C的行结束标志。如果未显式声明块表达式的返回值,则编译器会根据块内容自动进行推导。
块可变变量
如果某个局部变量使用__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在作用域,内存管理等方面具有自己独特的特性和需要留意的地方,在许多场景也很多实用的功能。虽然有时理解起来有点费劲,但是用好了,相信用好了可以大大提高代码可读性和效率等。