C++学习之普通函数指针与成员函数指针
来源:互联网 发布:linux oracle em打不开 编辑:程序博客网 时间:2024/05/18 00:53
函数指针(function pointer) 是通过指向函数的指针间接调用函数,相信很多人对指向一般函数的函数指针使用较多,而对指向类成员函数指针则比较的陌生。
一、普通函数指针
通常我们所说得函数指针指向一般普通函数指针,和其他的指针一样,函数指针指向某种特定的类型,所有被同一指针运用的函数必须指向某种特定的类型,所有被同一指针运用的函数必须具有相同的形参类型和返回类型.
int (*pf)(int, int); // 声明函数指针
这里,pf指向的函数类型是int (int, int),即函数的参数是两个int型,返回值也是int型。注:*pf两端的括号必不可少,如果不写这对括号,则pf是一个返回值int指针的函数。
Code
#include <iostream>
#include <string>
using namespace std;
typedef int (*pFun) (int,int);//typedef一个类型
int add(int a ,int b){
return a + b;
}
int mns(int a,int b){
return a - b;
}
string merge(const string& s1,const string& s2){
return s1 + s2;
}
int main(){
pFun pf1 = add;
cout << (*pf1)(2,3) << endl;//调用add函数
pf1 = mns;
cout << (*pf1)(8,1) << endl;//调用mns函数
string (*pf2)(const string&,const string&) = merge;//调用merge函数
cout << (*pf2)("hello","world") << endl;
return 0;
}
如示例代码,直接声明函数指针变量显得冗长而烦琐,所以我们可以使用typedef定义自己的函数指针类型。另外,函数指针还可以作为函数的形参类型,实参则可以直接使用函数名。
二、成员函数指针
成员函数指针(member function pointer)是指可以指向类的非静态成员函数的指针,类的静态成员不属于任何对象,因此无须特殊的指向静态成员指针,指向静态成员的指针和普通指针没有什么区别,与普通函数指针的区别是,成员函数指针不仅要指定目标函数的形参列表和返回值类型,还必须指出成员函数所属的类,因此,我们必须在*之前添加classname::以表示当前定义的指针指向classname的成员函数:
int (A::*pf)(int,int);//声明一个函数指针
同理,这里A::*pf两端的括号也是必不可少的,如果没有这对括号,则pf是一个返回A类数据成员(int型)指针的函数。注意:和普通函数指针不同的是,在成员函数和指向该成员的指针之间不存在自动转换规则。
pf = &A::add; // 正确:必须显式地使用取址运算符(&)
pf = A::add; // 错误
当我们初始化一个成员函数指针时,其指向了类的某个成员函数,但并没有指定该成员所属的对象——直到使用成员函数指针时,才提供成员所属的对象.
code
#include <iostream>
#include <string>
using namespace std;
class A;
typedef int (A::*pClassFun)(int,int);
class A{
public:
int add(int m,int n)
{
cout << m << " + " << n << " = " << m + n << endl;
return m + n;
}
int mns(int m,int n){
cout << m << " - " << n << "=" << m - n << endl;
return m - n;
}
int mul(int m,int n){
cout << m << " * " << n << " = " << m * n << endl;
return m * n;
}
int dev(int m,int n){
cout << m << " * " << n << " = " << m * n << endl;
return m * n;
}
int call(pClassFun fun,int m,int n){ //类内部接口
return (this ->*fun)(m,n);
}
};
int call(A obj,pClassFun fun,int m,int n)//类外部接口
{
return (obj.*fun)(m,n);
}
int main(){
A a;
cout << "member function 'call' : " << endl;
a.call(&A::add, 8, 4);
a.call(&A::mns, 8, 4);
a.call(&A::mul, 8, 4);
a.call(&A::dev, 8, 4);
cout << "external function 'call:'" << endl;
call(a, &A::add, 9, 3);
call(a, &A::mns, 9, 3);
call(a, &A::mul, 9, 3);
call(a, &A::dev, 9, 3);
return 0;
}
如示例所示,我们一样可以使用typedef定义成员函数指针的类型别名。另外,我们需要留意函数指针的使用方法:对于普通函数指针,是这样使用(*pf)(arguments),因为要调用函数,必须先解引用函数指针,而函数调用运算符()的优先级较高,所以(*pf)的括号必不可少;对于成员函数指针,唯一的不同是需要在某一对象上调用函数,所以只需要加上成员访问符即可:
(obj.*pf)(arguments) // obj 是对象
(objptr->*pf)(arguments) // objptr是对象指针
三、函数表驱动
对于普通函数指针和指向成员函数的指针来说,一种常见的用法就是将其存入一个函数表(function table)当中。当程序需要执行某个特定的函数时,就从表中查找对应的函数指针,用该指针来调用相应的程序代码,这个就是函数指针在表驱动法中的应用。
表驱动法(Table-Driven Approach)就是用查表的方法获取信息。通常,在数据不多时可用逻辑判断语句(if…else或switch…case)来获取信息;但随着数据的增多,逻辑语句会越来越长,此时表驱动法的优势就体现出来了。
#include<iostream>
#include<string>
#include<map>
using namespace std;
class A;
typedef int (A::*pClassFun)(int, int);
class A{
public:
A(){ // 构造函数,初始化表
table["+"] = &A::add;
table["-"] = &A::mns;
table["*"] = &A::mul;
table["/"] = &A::dev;
}
int add(int m, int n){
cout << m << " + " << n << " = " << m+n << endl;
return m+n;
}
int mns(int m, int n){
cout << m << " - " << n << " = " << m-n << endl;
return m-n;
}
int mul(int m, int n){
cout << m << " * " << n << " = " << m*n << endl;
return m*n;
}
int dev(int m, int n){
cout << m << " / " << n << " = " << m/n << endl;
return m/n;
}
// 查找表,调用相应函数
int call(string s, int m, int n){
return (this->*table[s])(m, n);
}
private:
map<string, pClassFun> table; // 函数表
};
// 测试
int main()
{
A a;
a.call("+", 8, 2);
a.call("-", 8, 2);
a.call("*", 8, 2);
a.call("/", 8, 2);
return 0;
}
上面是一个示例,示例中的“表”通过map来实现(当然也可以使用数组)。表驱动法使用时需要注意:一是如何查表,从表中读取正确的数据;二是表里存放什么,如数值或函数指针。
一、普通函数指针
通常我们所说得函数指针指向一般普通函数指针,和其他的指针一样,函数指针指向某种特定的类型,所有被同一指针运用的函数必须指向某种特定的类型,所有被同一指针运用的函数必须具有相同的形参类型和返回类型.
int (*pf)(int, int); // 声明函数指针
这里,pf指向的函数类型是int (int, int),即函数的参数是两个int型,返回值也是int型。注:*pf两端的括号必不可少,如果不写这对括号,则pf是一个返回值int指针的函数。
Code
#include <iostream>
#include <string>
using namespace std;
typedef int (*pFun) (int,int);//typedef一个类型
int add(int a ,int b){
return a + b;
}
int mns(int a,int b){
return a - b;
}
string merge(const string& s1,const string& s2){
return s1 + s2;
}
int main(){
pFun pf1 = add;
cout << (*pf1)(2,3) << endl;//调用add函数
pf1 = mns;
cout << (*pf1)(8,1) << endl;//调用mns函数
string (*pf2)(const string&,const string&) = merge;//调用merge函数
cout << (*pf2)("hello","world") << endl;
return 0;
}
如示例代码,直接声明函数指针变量显得冗长而烦琐,所以我们可以使用typedef定义自己的函数指针类型。另外,函数指针还可以作为函数的形参类型,实参则可以直接使用函数名。
二、成员函数指针
成员函数指针(member function pointer)是指可以指向类的非静态成员函数的指针,类的静态成员不属于任何对象,因此无须特殊的指向静态成员指针,指向静态成员的指针和普通指针没有什么区别,与普通函数指针的区别是,成员函数指针不仅要指定目标函数的形参列表和返回值类型,还必须指出成员函数所属的类,因此,我们必须在*之前添加classname::以表示当前定义的指针指向classname的成员函数:
int (A::*pf)(int,int);//声明一个函数指针
同理,这里A::*pf两端的括号也是必不可少的,如果没有这对括号,则pf是一个返回A类数据成员(int型)指针的函数。注意:和普通函数指针不同的是,在成员函数和指向该成员的指针之间不存在自动转换规则。
pf = &A::add; // 正确:必须显式地使用取址运算符(&)
pf = A::add; // 错误
当我们初始化一个成员函数指针时,其指向了类的某个成员函数,但并没有指定该成员所属的对象——直到使用成员函数指针时,才提供成员所属的对象.
code
#include <iostream>
#include <string>
using namespace std;
class A;
typedef int (A::*pClassFun)(int,int);
class A{
public:
int add(int m,int n)
{
cout << m << " + " << n << " = " << m + n << endl;
return m + n;
}
int mns(int m,int n){
cout << m << " - " << n << "=" << m - n << endl;
return m - n;
}
int mul(int m,int n){
cout << m << " * " << n << " = " << m * n << endl;
return m * n;
}
int dev(int m,int n){
cout << m << " * " << n << " = " << m * n << endl;
return m * n;
}
int call(pClassFun fun,int m,int n){ //类内部接口
return (this ->*fun)(m,n);
}
};
int call(A obj,pClassFun fun,int m,int n)//类外部接口
{
return (obj.*fun)(m,n);
}
int main(){
A a;
cout << "member function 'call' : " << endl;
a.call(&A::add, 8, 4);
a.call(&A::mns, 8, 4);
a.call(&A::mul, 8, 4);
a.call(&A::dev, 8, 4);
cout << "external function 'call:'" << endl;
call(a, &A::add, 9, 3);
call(a, &A::mns, 9, 3);
call(a, &A::mul, 9, 3);
call(a, &A::dev, 9, 3);
return 0;
}
如示例所示,我们一样可以使用typedef定义成员函数指针的类型别名。另外,我们需要留意函数指针的使用方法:对于普通函数指针,是这样使用(*pf)(arguments),因为要调用函数,必须先解引用函数指针,而函数调用运算符()的优先级较高,所以(*pf)的括号必不可少;对于成员函数指针,唯一的不同是需要在某一对象上调用函数,所以只需要加上成员访问符即可:
(obj.*pf)(arguments) // obj 是对象
(objptr->*pf)(arguments) // objptr是对象指针
三、函数表驱动
对于普通函数指针和指向成员函数的指针来说,一种常见的用法就是将其存入一个函数表(function table)当中。当程序需要执行某个特定的函数时,就从表中查找对应的函数指针,用该指针来调用相应的程序代码,这个就是函数指针在表驱动法中的应用。
表驱动法(Table-Driven Approach)就是用查表的方法获取信息。通常,在数据不多时可用逻辑判断语句(if…else或switch…case)来获取信息;但随着数据的增多,逻辑语句会越来越长,此时表驱动法的优势就体现出来了。
#include<iostream>
#include<string>
#include<map>
using namespace std;
class A;
typedef int (A::*pClassFun)(int, int);
class A{
public:
A(){ // 构造函数,初始化表
table["+"] = &A::add;
table["-"] = &A::mns;
table["*"] = &A::mul;
table["/"] = &A::dev;
}
int add(int m, int n){
cout << m << " + " << n << " = " << m+n << endl;
return m+n;
}
int mns(int m, int n){
cout << m << " - " << n << " = " << m-n << endl;
return m-n;
}
int mul(int m, int n){
cout << m << " * " << n << " = " << m*n << endl;
return m*n;
}
int dev(int m, int n){
cout << m << " / " << n << " = " << m/n << endl;
return m/n;
}
// 查找表,调用相应函数
int call(string s, int m, int n){
return (this->*table[s])(m, n);
}
private:
map<string, pClassFun> table; // 函数表
};
// 测试
int main()
{
A a;
a.call("+", 8, 2);
a.call("-", 8, 2);
a.call("*", 8, 2);
a.call("/", 8, 2);
return 0;
}
上面是一个示例,示例中的“表”通过map来实现(当然也可以使用数组)。表驱动法使用时需要注意:一是如何查表,从表中读取正确的数据;二是表里存放什么,如数值或函数指针。
0 0
- C++学习之普通函数指针与成员函数指针
- C++学习之普通函数指针与成员函数指针
- 普通函数指针与成员函数指针
- 普通函数,成员函数,静态成员函数与【指针】
- 普通函数指针与类成员函数指针的区别
- C++普通函数指针与成员函数指针实例解析
- c++ 成员函数 普通函数指针转换
- C语言深度剖析之—指针与内存地址(函数指针,普通指针,指针数组,数组的指针,指针的指针)
- C语言深度剖析之—指针与内存地址(函数指针,普通指针,指针数组,数组的指针,指针的指针)
- C语言深度剖析之—指针与内存地址(函数指针,普通指针,指针数组,数组的指针,指针的指针)
- 成员函数与函数指针
- 普通函数指针和指向成员函数指针(转载)
- 关于成员函数指针和普通函数指针的转换
- 类的普通成员函数的指针
- 类的普通成员函数的指针
- 类的普通成员函数的指针
- 函数指针与成员函数指针
- 函数指针与成员函数指针
- 原始套接字之PING(6)
- oracle配置属性文件
- MongoDB 副本集的搭建、应用
- 关于使用HttpURLConnection登录网站的问题
- 对C++中纯虚函数和抽象类的认识
- C++学习之普通函数指针与成员函数指针
- java IO操作
- 利用webview访问浏览网页
- 2015-4-20_OC
- Using Scene Builder with NetBeans IDE
- 【Unity3d】学习笔记(9)——写一个计时器工具
- UI开发----UIScrollView和UIPageControl简单模拟滚动视图
- HTML中size和maxlength的区别关系
- Ubuntu下Qt 无法显示菜单栏