委托与函数指针辨析

　　我们常见到C#技术文献用“类似C/C++函数指针的东西”介绍委托。这样好像是有道理的，因为二者的确有深层次的相通之处。委托和函数指针都描述了方法/函数的签名，并通过统一的接口调用不同的实现。但二者又有明显的区别，简单说来，委托对象是真正的对象，而函数指针变量只是函数的入口地址。对于高层应用来讲，委托的灵活性和适用范围更胜函数指针；但对于底层应用，函数指针则是不可替代的。下面分别是委托类型和函数指针类型定义的例子：

delegate int Fn(int a, int b) //C#委托

typedef int (*Fn)(int a, int b) //C++函数指针

　　从形式上看，二者的参数列表和返回值都是相同的，只是一个采用关键字delegate，一个采用指针符号*。似乎“相似”的说法更有把握了，但如果马上给二者划等号就操之过急了。我们先实际验证一下，看看到底有什么不同：

//C#

delegate int Fn(int a, int b) ;

class Adder{

　　　 private int c = 0;

　　　 public int Add(int a, int b){

　　　　　　　 return a + b + c;

　　　 }

　　　 public Adder(int c){ this.c = c; }

}

class Multiplier{

　　　 private int c = 0;

　　　 public int Multiple(int a, int b){

　　　　　　　 return a * b * c;

　　　 }

　　　 public Multiplier(int c){ this.c = c; }

}

Adder adder = new Adder(1);

Multiplier multiplier = new Multiplier(2);

Fn fn = adder.Add;

fn(1, 2); //结果为4

fn = multiplier.Multiple;

fn(2, 3); //结果为12

　　从上面的代码说明了两个问题：

　　1.委托对象可以指向不同类的方法，只要符合委托签名；

　　2.委托对象是有状态的（保存在指向的对象中），委托的行为不仅受到输入参数的影响，还受到目标对象状态的影响。

//C++

typedef int(*Fn)(int a, int b);

int Add(int a, int b) {
　　　 return a + b;
};

int Multiple(int a, int b) {
　　　 return a * b;
};

class Adder {
public:
　　　 Adder(int c) {
　　　　　　　 this->c = c;
　　　 }
　　　 int Add(int a, int b) {
　　　　　　　 return a + b + c;　
　　　 }
private:
　　　 int c;
};

typedef int(Adder::* Fm)(int a, int b);

int _tmain(int argc, _TCHAR* argv[])
{
　　　 Fn fn = Add;
　　　 std::cout << fn(1, 2) << std::endl;

　　　 fn = Multiple;
　　　 std::cout << fn(1, 2) << std::endl;

　　　 Adder adder(1);
　　　 Fm f = &Adder::Add;
　　　 std::cout << (adder.*f)(1, 2) << std::endl;
　　　 return 0;
}

　　C#中的委托是一种支持()操作符的特殊对象。这和C/C++的函数指针是有本质区别的，因为C/C++的函数指针变量并不具有对象性质，它只是单纯的函数入口地址。上面的Fn只能指向Add和Multiple两个普通函数，无法指向Adder类的Add方法。因为Adder类的Add方法的签名并非int(*)(int a, int b)，编译器会自动加上一个隐式的this指针参数，所以它的签名是类似int(*)(Adder *const this, int a, int b) 的。如果需要指向成员函数的指针，需要用typedef int(Adder::* Fm)(int a, int b)这样的形式加上类型限定符。 所以，C++的函数指针不能像C#委托一样指向不同类的方法；不具有对象的状态性质；在使用上函数指针也不如委托灵活。所以，当听到“委托就是类似C/C++函数指针”的说法的时候应该既理解其相似之处，又明了其差别。

　　Functor

　　我们常说C++是强大而复杂的语言，函数指针已经被C#委托PK下来了，难道C++就没有可以PK C#委托的大将吗？当然有！首先应该看到，函数指针并非C++的产物，而是继承自C，因此函数指针的局限其实是C的局限，与C++无关。我们说C#委托是支持()函数调用操作符的特殊对象，在C++中()操作符是可以被重载的，我们把重载了()操作符的对象称为functor。下面是一个functor的例子：

class Adder {
public:
　　　 Adder(int c) {
　　　　　　　 this->c = c;
　　　 }
　　　 int operator()(int a, int b) {
　　　　　　　 return a + b + c;
　　　 }
private:
　　　 int c;
};

int _tmain(int argc, _TCHAR* argv[]) {

　　　 Adder adder(1);
　　　 std::cout << adder(2, 3) << std::endl; //输出6, adder是functor-重载了()操作符的对象

　　　 return 0;
}

　　functor和委托对象有相似之处，都是支持()操作符的具有状态的对象。但functor还不是委托，为什么？因为委托类型是一种接口规范，函数指针类型也是，但functor本身不是接口规范。这里，请注意区分类型和对象之间的关系：委托类型和委托对象，函数指针类型和函数指针变量。functor可以等同于委托对象，但如何表达委托类型呢？应该看到，委托机制是一种运行时的动多态，委托对象可以与目标方法动态地绑定。由于C++并非基于虚拟机的语言，想直接动态绑定不同类型functor到统一的类型接口并不容易。但C++有一种强大的工具实现静多态，这就是模版：

　　模版

class Adder {
public:
　　　 Adder(int c) {
　　　　　　　 this->c = c;
　　　 }
　　　 int operator()(int a, int b) {
　　　　　　　 return a + b + c;
　　　 }
private:
　　　 int c;
};

class Multiplier {
public:
　　　 Multiplier(int c) {
　　　　　　　 this->c = c;
　　　 }

　　　 int operator()(int a, int b) {
　　　　　　　 return a * b * c;
　　　 }
private:
　　　 int c;
};

template<typename T>
void Do(T& f, int a, int b) {

　　　 int r = f(a, b);
　　　 std::cout << r << std::endl;
};

int _tmain(int argc, _TCHAR* argv[]) {
　　　 Adder adder(1);
　　　 Do(adder, 1, 2); //输出4

　　　 Multiplier multiplier(10);
　　　 Do(multiplier, 2, 3);　 //输出60

　　　 return 0;
}

　　可以认为函数模版Do表达了接口规范，它要求一个泛型类T支持()运算符、接受两个整形参数、返回可隐式转换为int的类型。对于不同类型Adder和Multiplier，编译器在编译时自动根据模版为不同的类型T生成了不同的Do重载函数，因此Do的调用形式是统一的，这就是所谓的静多态。有人谈到“模版为静态类型的C++赋予了几乎无类型的元编程能力”，这个例子算是个小小的窥视。STL中许多库方法都是通过模版来表达接口规范，调用者传入functor，其灵活性完全不输C#委托。

　　总结

　　1.C#委托对象是真正的对象，C/C++函数指针只是函数入口地址

　　2.C++的委托对象：functor

　　3.C++的静多态：模版

　　从上面的代码说明了两个问题：

　　1.委托对象可以指向不同类的方法，只要符合委托签名；

　　2.委托对象是有状态的（保存在指向的对象中），委托的行为不仅受到输入参数的影响，还受到目标对象状态的影响。

//C++

typedef int(*Fn)(int a, int b);

int Add(int a, int b) {
　　　 return a + b;
};

int Multiple(int a, int b) {
　　　 return a * b;
};

class Adder {
public:
　　　 Adder(int c) {
　　　　　　　 this->c = c;
　　　 }
　　　 int Add(int a, int b) {
　　　　　　　 return a + b + c;　
　　　 }
private:
　　　 int c;
};

typedef int(Adder::* Fm)(int a, int b);

int _tmain(int argc, _TCHAR* argv[])
{
　　　 Fn fn = Add;
　　　 std::cout << fn(1, 2) << std::endl;

　　　 fn = Multiple;
　　　 std::cout << fn(1, 2) << std::endl;

　　　 Adder adder(1);
　　　 Fm f = &Adder::Add;
　　　 std::cout << (adder.*f)(1, 2) << std::endl;
　　　 return 0;
}

　　C#中的委托是一种支持()操作符的特殊对象。这和C/C++的函数指针是有本质区别的，因为C/C++的函数指针变量并不具有对象性质，它只是单纯的函数入口地址。上面的Fn只能指向Add和Multiple两个普通函数，无法指向Adder类的Add方法。因为Adder类的Add方法的签名并非int(*)(int a, int b)，编译器会自动加上一个隐式的this指针参数，所以它的签名是类似int(*)(Adder *const this, int a, int b) 的。如果需要指向成员函数的指针，需要用typedef int(Adder::* Fm)(int a, int b)这样的形式加上类型限定符。 所以，C++的函数指针不能像C#委托一样指向不同类的方法；不具有对象的状态性质；在使用上函数指针也不如委托灵活。所以，当听到“委托就是类似C/C++函数指针”的说法的时候应该既理解其相似之处，又明了其差别。