用过C#的人,一般都知道委托和事件。
如果没有用过C#,我在这里简单解释一下委托,如果用过了,下面可以skip。
委托是一个方法声明,我们知道,在C语言中,可以通过函数指针表示一个地址的CALL方法,委托在C#中也差不多是干这样的工作。
但是委托有一些不同,主要的地方就是,在C++中, 函数指针并不是“面向对象”的 ,比如,我们有一个类CTest,类中有一个成员方法foo,此时如果我们要通过函数指针的方式来调用foo的话,因为foo是类CTest的成员,我们需要CTest的实例this指针。
比方说:
它的成员函数指针应该这样写:
如果这个成员是const修饰的,则这样:
调用怎么办呢?这样:
如果你这样写:
是会出问题的,因为->*这个运算符的优先级很低。。。。
如果CTest不是在HEAP上的,是在stack上的呢?
这样:
这些奇葩的语法,->*、.*这种神奇的运算符真是蛋疼。
而有时候我们又无法逃避,比如启动线程的时候,我们一般从一个static函数通过这种sb的语法,把类this当作参数传过去,然后跑过去类的成员函数。
但是在C#中, 委托则是面向对象的 ,你可以用委托表示一个类实例的成员函数指针。
比如:
输出:
123
1234
this CNewTest.
也就是,在C#中,只要方法适应委托声明,那都可以call过去,C#为我们自动隐藏了this指针。
所以,就在C#中诞生了事件,一个提供者对象通过定义一个委托,然后把委托声明为事件,此时其他监听者对象就可以把这个事件跟自己的成员函数挂钩上来,然后等待提供者在需要的时候调用这个委托,则调用到了成员函数,就是触发了事件。
为什么声明为事件,直接暴露委托不是可以了么?
这是一个逻辑问题,如果直接暴露委托,那订阅者是可以主动触发委托的,订阅者可以是主动的,还“订阅”个屁啊。
如果用事件,则订阅者只能等待提供者来触发委托,此时订阅者,只能是“被动”的。
这个概念,用C++的来理解,也就是:
类A有一个public的ptr、ptr_this,此ptr保存了一个成员函数指针,ptr_this保存ptr的类实例。
类B把这个ptr改成他自己的,ptr_this改成它的this,适应这个成员函数指针的声明。
类A在某些工作搞定后,检查一下ptr != nullptr,然后call这个ptr,就调用到了类B的成员函数。
但是C++做这些有天然的不足,ptr不是nullptr倒是可以,但是可能类B早被delete了,但是存储在你类A的ptr依然不是nullptr,你call直接挂,当然用C11的shared_ptr、weak_ptr这种东西,倒是也是一个解决方案,不过总的来说,就是不爽,这得多麻烦?
也就是C++,我们还是难以跳出手动管理内存这个圈子。
C#的GC自动管理则完全通杀这些问题。
还有一个就是,C#中,委托是一个多播的实现,比如:
输出:
123
123
this CNewTest.
简单的说,就是cbF这个玩意儿里面,有一个泛型的List。。。。在Call的时候,是跑表来一个个call的,十分方便。
说白了,委托就是一个【方法的接口】,只要方法对就行,安全又舒服。
于是委托+事件这种多播实现,就能很好的做出一个观察者模式。
那么多弊端出来了,C11委员会也发现了这些问题,就加入了一个std::function,这个东西呢,说简单了,它就是差不多用来实现委托的功能的(不是实现事件哦)。
还是回到上面那个C#写的ConsoleApplication1,我们用std::function重来一遍。
(编译环境为VS2013,Windows SDK。)
使用std::function前,需要包含#include <functional>。
我们准备一下函数:
一个直接的函数,一个类成员函数。
首先我们来调用StaticCallback:
输出:123
这样写有点多啊,恩,我们是C++,有typedef。
typedef多了一行代码,而且不直观,不怕,我们有auto。
在实际使用中,视情况而定用auto还是typedef,二者配合是比较好的。
( std::function还可以配合lamdba这种匿名函数来使用,有逆天级别的效果 ,这里不太深究,可能我日后会写lamdba的文章。)
是不是感觉,这tmd的太像C#的委托了?不过C#的委托是new的,我们C++的则可以直接开在stack上,当然我们new,也可以。
然后我们来测试调用成员函数指针:
输出:
123
1234
this CNewTest.
我们使用std::bind,生成了一个std::function,调用这个function即可调用过去成员函数了。
现在我们的CNewTest是在Heap上的,我们如果在stack上呢?估计你肯定想到了:
很多人可能会奇怪,后面这个std::placeholders::_1是什么意思?
其实就是表示bind上去的这个函数方法有1个参数,这个参数是个泛型的,如果我们不让其生成泛型参数,而是直接写一个绝对值,比如:
则输出是:
123
3333
this CNewTest.
即便你这样调用:
输出依然是上面的,可以理解为一个强制默认参数的作用。
std::function在实际应用中,假设我们有一个函数,它有一个callback参数,当某些任务完成后,它call这个callback函数:
则可以这样调用:
输出:
1
this CNewTest.
2
this CNewTest.
3
this CNewTest.
前面说了,std::function是可以new的,也就是,我们可以设计这样一个函数:
然后这样调用:
shared_ptr会保证我们new的std::function被安全的delete。
这个指针我们可以到处扔。。。。比C#的委托自由度大很多。
std::function本身没有多播的实现,你可以自己使用std::vector等东西包起来自己做一个。
如果没有用过C#,我在这里简单解释一下委托,如果用过了,下面可以skip。
委托是一个方法声明,我们知道,在C语言中,可以通过函数指针表示一个地址的CALL方法,委托在C#中也差不多是干这样的工作。
但是委托有一些不同,主要的地方就是,在C++中, 函数指针并不是“面向对象”的 ,比如,我们有一个类CTest,类中有一个成员方法foo,此时如果我们要通过函数指针的方式来调用foo的话,因为foo是类CTest的成员,我们需要CTest的实例this指针。
比方说:
- class CTest
- {
- public:
- void foo(int i) {}
- };
- void (CTest::*FuncFoo)(int);
- void (CTest::*FuncFoo)(int) const;
调用怎么办呢?这样:
- CTest* pThis = new...;
- FuncFoo pThis_foo = &CTest::foo;
- (pThis->*pThis_foo)(123);
- pThis->*pThis_foo(123);
如果CTest不是在HEAP上的,是在stack上的呢?
这样:
- CTest pThis;
- (pThis.*pThis_foo)(123);
这些奇葩的语法,->*、.*这种神奇的运算符真是蛋疼。
而有时候我们又无法逃避,比如启动线程的时候,我们一般从一个static函数通过这种sb的语法,把类this当作参数传过去,然后跑过去类的成员函数。
但是在C#中, 委托则是面向对象的 ,你可以用委托表示一个类实例的成员函数指针。
比如:
- namespace ConsoleApplication1
- {
- public delegate void CallbackFunc(int i);
- //void (callback*)(int i);
- class CNewTest
- {
- private static readonly string _str = "this CNewTest.";
- public void MemberCallback(int i)
- {
- System.Diagnostics.Debug.WriteLine(i.ToString());
- System.Diagnostics.Debug.WriteLine(_str);
- }
- }
- class Program
- {
- static void StaticCallback(int i)
- {
- System.Diagnostics.Debug.WriteLine(i.ToString());
- }
- static void Main(string[] args)
- {
- CallbackFunc StaticCbF = new CallbackFunc(StaticCallback);
- StaticCbF(123); //Call to static void StaticCallback(int i)
- CNewTest c = new CNewTest();
- CallbackFunc MembCbF = new CallbackFunc(c.MemberCallback);
- MembCbF(1234); //Call to c->MemberCallback
- Console.ReadKey();
- }
- }
- }
123
1234
this CNewTest.
也就是,在C#中,只要方法适应委托声明,那都可以call过去,C#为我们自动隐藏了this指针。
所以,就在C#中诞生了事件,一个提供者对象通过定义一个委托,然后把委托声明为事件,此时其他监听者对象就可以把这个事件跟自己的成员函数挂钩上来,然后等待提供者在需要的时候调用这个委托,则调用到了成员函数,就是触发了事件。
为什么声明为事件,直接暴露委托不是可以了么?
这是一个逻辑问题,如果直接暴露委托,那订阅者是可以主动触发委托的,订阅者可以是主动的,还“订阅”个屁啊。
如果用事件,则订阅者只能等待提供者来触发委托,此时订阅者,只能是“被动”的。
这个概念,用C++的来理解,也就是:
类A有一个public的ptr、ptr_this,此ptr保存了一个成员函数指针,ptr_this保存ptr的类实例。
类B把这个ptr改成他自己的,ptr_this改成它的this,适应这个成员函数指针的声明。
类A在某些工作搞定后,检查一下ptr != nullptr,然后call这个ptr,就调用到了类B的成员函数。
但是C++做这些有天然的不足,ptr不是nullptr倒是可以,但是可能类B早被delete了,但是存储在你类A的ptr依然不是nullptr,你call直接挂,当然用C11的shared_ptr、weak_ptr这种东西,倒是也是一个解决方案,不过总的来说,就是不爽,这得多麻烦?
也就是C++,我们还是难以跳出手动管理内存这个圈子。
C#的GC自动管理则完全通杀这些问题。
还有一个就是,C#中,委托是一个多播的实现,比如:
- static void Main(string[] args)
- {
- //CallbackFunc StaticCbF = new CallbackFunc(StaticCallback);
- //StaticCbF(123); //Call to static void StaticCallback(int i)
- //CNewTest c = new CNewTest();
- //CallbackFunc MembCbF = new CallbackFunc(c.MemberCallback);
- //MembCbF(1234); //Call to c->MemberCallback
- CallbackFunc cbF = new CallbackFunc(StaticCallback);
- CNewTest c = new CNewTest();
- cbF += c.MemberCallback;
- cbF(123);
- Console.ReadKey();
- }
123
123
this CNewTest.
简单的说,就是cbF这个玩意儿里面,有一个泛型的List。。。。在Call的时候,是跑表来一个个call的,十分方便。
说白了,委托就是一个【方法的接口】,只要方法对就行,安全又舒服。
于是委托+事件这种多播实现,就能很好的做出一个观察者模式。
那么多弊端出来了,C11委员会也发现了这些问题,就加入了一个std::function,这个东西呢,说简单了,它就是差不多用来实现委托的功能的(不是实现事件哦)。
还是回到上面那个C#写的ConsoleApplication1,我们用std::function重来一遍。
(编译环境为VS2013,Windows SDK。)
使用std::function前,需要包含#include <functional>。
我们准备一下函数:
- class CNewTest
- {
- char m_str[128];
- public:
- void MemberCallback(int i)
- {
- strcpy(m_str,"this CNewTest.\n");
- printf("%d\n",i);
- printf(m_str);
- }
- };
- void StaticCallback(int i)
- {
- printf("%d\n",i);
- }
一个直接的函数,一个类成员函数。
首先我们来调用StaticCallback:
- int main()
- {
- std::function<void (int)> fp = std::function<void (int)>(&StaticCallback);
- fp(123);
- getchar();
- return 0;
- }
这样写有点多啊,恩,我们是C++,有typedef。
- int main()
- {
- typedef std::function<void (int)> declare_fp;
- declare_fp fp = declare_fp(&StaticCallback);
- fp(123);
- getchar();
- return 0;
- }
typedef多了一行代码,而且不直观,不怕,我们有auto。
- int main()
- {
- auto fp = std::function<void (int)>(&StaticCallback);
- fp(123);
- getchar();
- return 0;
- }
( std::function还可以配合lamdba这种匿名函数来使用,有逆天级别的效果 ,这里不太深究,可能我日后会写lamdba的文章。)
是不是感觉,这tmd的太像C#的委托了?不过C#的委托是new的,我们C++的则可以直接开在stack上,当然我们new,也可以。
- int main()
- {
- typedef std::function<void (int)> declare_fp;
- declare_fp* fp = new declare_fp(&StaticCallback);
- (*fp)(123);
- delete fp; //手动删除
- getchar();
- return 0;
- }
然后我们来测试调用成员函数指针:
- int main()
- {
- auto fp = std::function<void (int)>(&StaticCallback);
- fp(123);
- CNewTest* c = new CNewTest();
- auto fp2 = std::bind(&CNewTest::MemberCallback,c,std::placeholders::_1);
- fp2(1234);
- delete c;
- getchar();
- return 0;
- }
123
1234
this CNewTest.
我们使用std::bind,生成了一个std::function,调用这个function即可调用过去成员函数了。
现在我们的CNewTest是在Heap上的,我们如果在stack上呢?估计你肯定想到了:
- CNewTest c;
- auto fp2 = std::bind(&CNewTest::MemberCallback,&c,std::placeholders::_1);
- fp2(1234);
很多人可能会奇怪,后面这个std::placeholders::_1是什么意思?
其实就是表示bind上去的这个函数方法有1个参数,这个参数是个泛型的,如果我们不让其生成泛型参数,而是直接写一个绝对值,比如:
- CNewTest* c = new CNewTest();
- auto fp2 = std::bind(&CNewTest::MemberCallback,c,3333);
- fp2();
123
3333
this CNewTest.
即便你这样调用:
- CNewTest* c = new CNewTest();
- auto fp2 = std::bind(&CNewTest::MemberCallback,c,3333);
- fp2(1234);
std::function在实际应用中,假设我们有一个函数,它有一个callback参数,当某些任务完成后,它call这个callback函数:
- void DoWork(std::function<void (int)> callback)
- {
- //DoWork....
- int result[] = {1,2,3};
- for (int i : result)
- callback(i);
- }
则可以这样调用:
- int main()
- {
- CNewTest c;
- auto fp2 = std::bind(&CNewTest::MemberCallback,&c,std::placeholders::_1);
- DoWork(fp2);
- getchar();
- return 0;
- }
输出:
1
this CNewTest.
2
this CNewTest.
3
this CNewTest.
前面说了,std::function是可以new的,也就是,我们可以设计这样一个函数:
- void DoWork2(std::shared_ptr<std::function<void (int)>> callback)
- {
- //DoWork2....
- int result[] = {1,2,3};
- for (int i : result)
- (*callback.get())(i);
- }
然后这样调用:
- int main()
- {
- {
- CNewTest c;
- auto fp = std::make_shared<std::function<void (int)>>
- (std::function<void (int)>(std::bind(&CNewTest::MemberCallback,&c,std::placeholders::_1)));
- DoWork2(fp);
- //delete fp.
- }
- getchar();
- return 0;
- }
shared_ptr会保证我们new的std::function被安全的delete。
这个指针我们可以到处扔。。。。比C#的委托自由度大很多。
std::function本身没有多播的实现,你可以自己使用std::vector等东西包起来自己做一个。