类成员函数指针浅析

阅读更多

今天看某软件的源代码时，发现有这样一行

1. typedefCPB_RETVAL(CPBprb_Prb::*CPBprb_action)(CPBprb_Prb&,unsigned);

其中CPB_RETVAL是一个enum类型，CPBprb_Prb是一个类，CPBprb_action在代码中其他地方没有找到定义。因不知这行代码所为何意，遂在论坛发贴请教 http://topic.csdn.net/u/20080908/11/0f127830-8c90-414d-9bab-5d946b115522.html?seed=1500702230。

承蒙众多高手赐教，才知上段代码定义了成员函数指针 类型CPBprb_action，该类型函数有2个参数，类型分别为CPBprb_Prb &, unsigned，返回值类型为CPB_RETVAL。此函数指针的类型有个定义域，它是类CPBprb_Prb的成员 （CPBprb_Prb::*CPBprb_action）。

另外， CPBprb_action不仅可以指向CPBprb_Prb的成员函数，也可以指向CPBprb_Prb的派生类成员函数。甚至,CPBprb_Prb里可以根本就没有任何诸如CPB_RETVAL functionName (CPBprb_Prb &, unsigned)这样的函数,而完全可以在CPBprb_Prb的派生类里去增加 CPB_RETVAL functionName (CPBprb_Prb &, unsigned);这样的函数，如：

1. #include
3. classA
4. {
5. public:
6. A(){};
7. virtual~A(){};
8. };
10. classB:publicA
11. {
12. public:
13. B(){};
14. ~B(){};
16. intFb(inta){returna*a;}
17. };
19. typedefint(A::*Myfunction)(int);
21. intmain()
22. {
23. B*pB=newB;
24. Myfunctionpf=(Myfunction)(&B::Fb);
25. intretValue=(pB->*pf)(3);
26. std::cout<
27. std::cin>>retValue;
29. return1;
30. }

通过typedef int (A::*Myfunction)(int);定义的Myfunction是A的成员（函数指针），但只能在类外定义。

需要指出的是，使用指向成员函数的指针变量是比较危险的!因此不建议这么用。

（上文引用了论坛中对我帖子的回复，再次对关心并帮助我的人表示感谢。）


PS：

函数指针(全局函数/类成员函数)和函数对象

（原文链接： http://www.ccrun.com/article.asp?i=1005&d=sc37og）

关键字：函数指针 全局函数 类成员函数 函数对象 Function object

作者：ErranLi 更新：2007-01-06 02:31:47 浏览：9166

函数指针(全局函数/类成员函数)、函数对象(Functionobject)

一.函数指针类型为全局函数.

#include"stdafx.h"

#include
usingnamespacestd;

classTestAction;

typedefvoid(*fp)(int);

voidDrink(inti)
{
cout<<"No."<"drink..."< }

voidEat(inti)
{
cout<<"No."<"eat..."< }

classTestAction
{
public:
fptestAct;

voidTestAct(inti)
{
if(testAct!=NULL)
{
testAct(i);
}
}
};

intmain(intargc,char*argv[])
{
TestActiondoact;
doact.testAct=&Drink;
doact.TestAct(0);
doact.TestAct(1);
doact.TestAct(2);
doact.testAct=&Eat;
doact.TestAct(0);
doact.TestAct(1);
doact.TestAct(2);
return0;
}

二.函数指针类型为类成员函数.

#include"stdafx.h"

#include
usingnamespacestd;

classAction;
classTestAction;

//函数指针类型为类Action的成员函数
typedefvoid(Action::*fp)(int);

classAction
{
public:
voidDrink(inti)
{
cout<<"No."<"drink..."< }

voidEat(inti)
{
cout<<"No."<"eat..."< }
};

classTestAction
{
public:
//定义一个函数指针
fptestAct;
//Action对象实例,该指针用于记录被实例化的Action对象
Action*pAction;

voidTestAct(inti)
{
if((pAction!=NULL)&&(testAct!=NULL))
{
//调用
(pAction->*testAct)(i);
}
}
};

intmain(intargc,char*argv[])
{
Actionact;
TestActiondoact;
doact.pAction=&act;
doact.testAct= &Action::Drink;
doact.TestAct(0);
doact.TestAct(1);
doact.TestAct(2);
doact.testAct= &Action::Eat;
doact.TestAct(0);
doact.TestAct(1);
doact.TestAct(2);
return0;
}

三.函数对象(Functionobject)
// 本文转自 C++Builder研究 - http://www.ccrun.com/article.asp?i=1005&d=sc37og

#include"stdafx.h"

#include
#include

usingnamespacestd;

classAction;
classDrink;
classEat;
classTestAction;

classAction
{
public:
intoperator()(inti)
{
Act(i);
returni;
}

virtualvoidAct(inti)=0;
};

classDrink:publicAction
{
voidAct(inti)
{
cout<<"No."<"drink..."< }
};

classEat:publicAction
{
voidAct(inti)
{
cout<<"No."<"eat..."< }
};

classTestAction
{
public:
voidTestAct(inti,Action&testAct)
{
testAct(i);
}
};

intmain(intargc,char*argv[])
{
TestActiondoact;
doact.TestAct(0,Drink());
doact.TestAct(1,Drink());
doact.TestAct(2,Drink());
doact.TestAct(0,Eat());
doact.TestAct(1,Eat());
doact.TestAct(2,Eat());
return0;
}

虽然传递函数指针被广泛应用于事件驱动系统中，以此实现回调函数通过指针来调用。但C++还是提供了另外一种可供选择的办法，即函数对象，利用它可以 避免使用函数指针。这样做有几个优点。首先，因为对象可以在内部修改而不用改动外部接口，因此设计更灵活，更富有弹性。函数对象也具备有存储先前调用结 果的数据成员。。此外，编译器可以内联函数对象，从而进一步增强性能。函数对象可以具体表达依赖成员模板的通用算法,这些算法借助普通的函数指针难 以完成。例用函数对象实现了一个通用的Negation算法操作：

#include"stdafx.h"
#include

usingnamespacestd;

classNegate
{
public:
template<classT>Toperator()(Tt)const
{
return-t;
}
};

voidCallback(intn,constNegate&neg) //传递一个函数对象
{
n=neg(n); //调用重载的()操作来对n进行negate操作
cout< }

intmain(intargc,char*argv[])
{
//调用方式一
Callback(5,Negate());

//调用方式二
Negateneg;
cout< cout<__int32(39999999))<
return0;
}

STL库中定义了很多函数对象以供相关算法调用，如模板化的函数对象greater<>或者less<>:

vector<int>vi;
//..填充向量
sort(vi.begin(),vi.end(),greater<int>());//降序(descending)
sort(vi.begin(),vi.end(),less<int>());//升序(ascending)

本文转自：http://www.cppblog.com/erran/archive/2006/12/26/16868.html

函数对象（function object）,又名仿函数（functor),是重载了operator（）的一个类，其实在stl算法中有大量运用，c++标准预定义的如 less <>,greater <>,bind2nd <>等
为什么引入仿函数？
原因：
１．仿函数有具体型别，可用在模板参数，而函数不行
２．同类仿函数可有不同植，可代表不同状态，比函数灵活（须定义多个）
３．仿函数可能比普通函数快
．．．．．．．．可能还有，不过凭印象就这些了