C++使用模板、函数指针、接口和lambda表达式这四种方法做回调函数的区别比较

　　在C++中，两个类之间存在一种关系，某个类需要另外一个类去完成某一个功能，完成了之后需要告知该类结果，这种最普通最常见的需求，往往使用回调函数来解决。

　　如题，我总结下来有这么四种方式可以完成这项功能，下面来一一分析：

　　1、使用模板

 // CppTest.cpp : 定义控制台应用程序的入口点。
 //

 #include "stdafx.h"
 #include <stdlib.h>
 #include <math.h>

 template<typename T>
 class MathTemplate
 {
     int ops1,ops2;
     int result;
 public:
     void Add(int a,int b,T callback)
     {
         ops1 = abs(a);   /* 实际上这个函数可能非常复杂，非常耗时，这样回调更突显作用*/
         ops2 = abs(b);

         result = ops1+ops2;

         callback.showResult(result);
     }
 };

 class Result
 {
 public:
     void showResult(int res)
     {
         printf("result = %d\n",res);
     }
 };

 int _tmain(int argc, _TCHAR* argv[])
 {
     Result reShow;
     MathTemplate<Result> math;
     math.Add(,,reShow);

     system("pause");
     return ;
 }

　　说明：结果类需要知道数学类的处理结果（下面都会使用这个例子），把数学类方法定义为模板函数，回调函数以模板变量的形式传递进去。

　　优点：两个类耦合度低，数学类不需要知道结果类，结果类因为需要数学类处理，肯定要包括数学类。

　　缺点：写数学类时，必须要知道结果类有showResult这个方法。

　　2、使用函数指针

 // CppTest.cpp : 定义控制台应用程序的入口点。
 //

 #include "stdafx.h"
 #include <stdlib.h>
 #include <math.h>

 class Result;

 typedef void (Result::*CallbackPtr)(int);

 class MathCallBack
 {
     int ops1,ops2;
     int result;
 public:
     void Add(int a,int b,Result *caller,CallbackPtr callback)
     {
         ops1 = abs(a);   /* 实际上这个函数可能非常复杂，非常耗时，这样回调更突显作用*/
         ops2 = abs(b);

         result = ops1+ops2;

         (caller->*callback)(result);
     }
 };

 class Result
 {
 public:
     void showResult(int res)
     {
         printf("result = %d\n",res);
     }
 };

 int _tmain(int argc, _TCHAR* argv[])
 {
     Result reShow;
     MathCallBack math;

     math.Add(,,&reShow,&Result::showResult);

     system("pause");

     return ;
 }

　　说明：跟上面一样，结果类需要知道数学类的处理结果，主要注意的是C++函数指针的写法与调用，必须以(对象.*函数指针)(参数)的形式调用。所以，传递回调函数时需要传入调用对象。

　　缺点：这种方法用起来没有优点，直接说缺点，耦合度高，数学类需要直接知道结果类，数学类不能重用，调用方式写起来也是别扭。

　　3、使用接口

 // CppTest.cpp : 定义控制台应用程序的入口点。
 //

 #include "stdafx.h"
 #include <stdlib.h>
 #include <math.h>

 class Result;

 class IProcessResult
 {
 public:
     virtual void ProcessResult(int result)=;
 };

 class MathCallBack
 {
     int ops1,ops2;
     int result;
 public:
     void Add(int a,int b,IProcessResult *process)
     {
         ops1 = abs(a);   /* 实际上这个函数可能非常复杂，非常耗时，这样回调更突显作用*/
         ops2 = abs(b);

         result = ops1+ops2;

         process->ProcessResult(result);
     }
 };

 class Result:public IProcessResult
 {
 public:
     void ProcessResult(int res)
     {
         printf("result = %d\n",res);
     }
 };

 int _tmain(int argc, _TCHAR* argv[])
 {
     Result reShow;
     MathCallBack math;

     math.Add(,,&reShow);

     system("pause");

     return ;
 }

　　说明：功能一模一样，一样以回调的方式显示结果。

　　优点：典型的面向接口编程，即结果类针对结果处理接口编程，不针对具体编程，降低耦合度。

　　缺点：程序中多了一个接口类，多了一个文件，不要小看多了一个文件，在大型项目工程里，有非常多的类似类之间关系，这样做会多出很多只有一个接口函数的类。

　　4、使用lambda表达式

 // CppTest.cpp : 定义控制台应用程序的入口点。
 //

 #include "stdafx.h"
 #include <stdlib.h>
 #include <math.h>
 #include <iostream>
 #include <functional>

 class MathCallBack
 {
     int ops1,ops2;
     int result;

 public:
     void Add(int a,int b,std::function<void (int)> func)
     {
         ops1 = abs(a);   /* 实际上这个函数可能非常复杂，非常耗时，这样回调更突显作用*/
         ops2 = abs(b);

         result = ops1+ops2;
         func(result);
     }
 };

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

     math.Add(,,[](int result) -> void {
             printf("result = %d\n",result);
         });

     system("pause");

     return ;
 }

　　说明：功能一模一样，一样以回调的方式显示结果。注意看lambda的回调函数类型哦！

　　优点：不用多说，整个代码简洁了不知道多少倍，优点无数。

　　总结：其实写这个博文就是为了学习C++的lambda表达式，在自己的项目中前3中方法都用了，始终感觉耦合度大，代码不简洁。见识过C#中lambda表达式的巨大优势，就知道C++一定能做到。