函数指针定义
普通函数指针
函数指针可以理解为指向该类型函数的指针
- 函数指针定义:返回值类型 (*函数指针名)(参数列表)。如:
int (*fp)(int a)
该段代码定义了一个函数指针,该指针可以用于指向返回值类型为int,只有一个int类型参数的函数。
- 函数指针赋值:函数指针赋值有两种方式
- 直接赋值:
函数指针 = 函数名
- 取地址符赋值:
函数指针 = &函数名
- 直接赋值:
- 调用:函数指针的使用方式和普通函数调用别无二致
例子如下:
#include <iostream>
using namespace std;
int add(int b) { // 普通函数
return b;
}
int main() {
int (*fp) (int fb); // 定义函数指针
fp = add; // 函数指针赋值
fp(3); // 通过函数指针调用函数
fp = &add;
fp(5);
}
typedef 简化指针
上述定义函数指针的方式,函数指针名每次都需要通过int (*fp1)(int fb)
的方式才能重新定义。稍显复杂,可以通过typedef
的方式,简化定义。
int main() {
typedef int (*fp) (int fb);
fp fp1 = add;
fp fp2 = add;
fp1(3);
}
typedef
可以让函数指针一次定义,多次赋值。
成员函数指针
指向类成员函数的函数指针和普通函数指针的区别在于,前者不仅需要匹配参数类型和个数,以及返回值类型,还要指定对应的类类型。根本原因是,普通的成员函数函数列表中有一个隐藏的this
指针,只有被绑定到类对象上或者某个指针上,才能够获得被调用对象的this
指针,最终才能调用类的成员函数。
在C++的函数中,所有类对象都有一份自己的数据成员拷贝。但是成员函数却是共享的,为了区分是那个对象调用了成员函数,就需要指定
this
指针。this
被隐式申明在所有普通成员函数列表中,所以,我们不会在普通成员函数列表中看到this
指针。
类普通成员函数指针定义,只需要在普通函数指针定义的基础上指定具体的类类型就好:
- 成员函数指针定义一:返回值 (类名::*函数指针名)(参数列表)。如:
int (类名::*fp)(int a);
- 成员函数指针定义二:typedef 返回值 (类名::*函数指针名)(参数列表)。
与普通函数定义的区别仅在于,类普通成员需要指定具体的类类型就好。
-
成员函数指针赋值:指针类型名 指针名 = &类型::成员函数名。如:
fp ptr = &类名::函数名;
-
调用:成员函数指针有两种调用方式,一种是通过类实例调用:.指针名,一种是通过指针调用:->指针名
-
通过实例调用:(类对象.*指针名)(参数列表);
-
通过指针调用:(类指针->*指针名)(参数列表);
在这里的调用中,如果没有前面的括号,按照操作赋的优先级,括号优先于.操作符,类似于
类对象.*指针名(参数列表)
的表达式将会报错。
-
实例如下:
#include <iostream>
using namespace std;
class D;
typedef void (D::*afp)(int);
class D {
public:
void test(int number) {
value = number;
cout << number << endl;
}
private:
int value;
};
int main() {
afp fp = &D::test;
D d;
D* dptr = new D;
(d.*fp)(10);
(dptr->*fp)(100);
}
数据成员指针
指向数据成员的指针与指向函数成员函数指针类似
class D;
typedef void (D::*afp)(int);
class D {
public:
void test(int number) {
value = number;
cout << number << endl;
}
int value;
};
typedef int (D::*numptr); // 没有参数列表
int main() {
afp fp = &D::test;
D d;
D* dptr = new D;
(d.*fp)(10);
(dptr->*fp)(100);
numptr dataptr = &D::value;
cout << d.*dataptr << endl;
cout << dptr->*dataptr << endl;
}
静态成员指针
类的静态成员和普通成员的区别在于,普通成员属于类的实例,而静态成员属于类。类的静态成员由类的所有实例对象所共享,所以不需要this指针。在函数指针的定义上,类的静态成员函数指针和其它普通的函数指针定义完全一致。
typedef int (*fp)();
class D {
public:
static int func() {
return staticMember;
}
static const int staticMember = 10;
};
int main() {
fp fpp = &D::func;
cout << fpp() << endl;
}
函数指针的应用
函数指针作函数参数
函数指针作为函数参数,来完成回调也是C/C++中的典型应用场景,通常将函数指针指向的函数作为回调函数使用。
#include <iostream>
using namespace std;
void print(int (*fp) (int a), int c) {
cout << fp(c) << endl; // 函数指针作为函数参数,在函数执行过程中执行
}
int add(int b) {
return b;
}
int main() {
typedef int (*fp) (int a);
fp fp3 = add;
print(fp3(10), 20);
}
这里,print函数的第一个参数int (*fp)(int a)
就是作为参数的函数指针,其中参数名可以参略:如int (*fp)(int)
,如果是多个参数的情况,也可以写成int (*fp) (int, int...)
。
利用函数指针,还可以组成函数指针数组,这样做的意义同样在于回调。如,在观察-消费者设计模型中,观察者中通常会维护一个消费者结构(可以是数组、列表、队列),以便在目标对象发生变化时通知消费者。在C/C++中就可以通过函数指针,来具体执行消费者函数。
函数指针数组和普通的数据差别不大:
#include <iostream>
using namespace std;
typedef void (*fp) (void);
void print() {
cout << "print" << endl;
}
int main() {
fp fp1 = print;
fp fp2 = print;
fp fp3 = print;
fp fps[] = {fp1, fp2, fp3};
fps[1]();
}
指针函数(即返回指针的函数)
指针函数的一般定义形式如下:
-
** 指针函数的定义 :
返回值类型 *函数名(参数列表)
**按照符号的优先级,先算括号,表明这是一个函数,再看符号** * **, 表明这个函数返回的是一个指针, 返回值类型表明该指针的类型。
指针函数和函数指针的定义非常类似,如前所述,函数指针的定义:
返回值类型 (*指针名)(参数列表)
。区别仅仅是一个括号,我们按照符号的优先级,重新解读一下函数指针的定义。依然先算括号**
(*指针名)
表明这是一个指针。(参数列表)
**,表明该指针指向的是一个函数, 返回值类型表明该函数的返回值所以,函数指针本质是一个指针,指向的是一个函数。指针函数本质是一个函数,返回的是一个指针。
用函数指针作为指针函数的返回值
指针函数定义
指针函数与普通函数的区别在于,普通函数的返回值是int
,float
, double
等类型,而指针函数的返回值可以是int
等类型的指针,也可以是函数指针。
我们来看一个例子:
int (*(func(int)))(int a);
该例子初一看,比较复杂。根据前面说的符号的优先级解读:
(func(int)
表明func是一个函数。(*(func(int)))
中的*表明func的返回值是一个指针。- 最后的
(int a)
表明该指针是一个函数。 - 返回值中的
int
,表明指针指向的函数返回值为int类型。
虽说,这么写没什么问题,但是可读性太低。通常,我们会用typedef来简化书写。上例可以简化成:
typedef int (*Funtype)(int a);
Funtype func(int); // 简化后的指针函数
指针函数应用
指针函数在设计模式中经常碰到,以一个简单工厂模式举例:
#include <iostream>
#include "string"
using namespace std;
string produceA() { // 实际调用的函数 A
return "A";
}
string produceB() { // 实际调用的函数 B
return "B";
}
string produceC() { // 实际调用的函数 C
return "C";
}
typedef string (*produce)(void); // 定义函数指针类型
produce getProduce(int type) { // 指针函数
switch (type) { // 根据参数值返回对应的函数指针
case 1:
return produceA;
case 2:
return produceB;
case 3:
return produceC;
}
return produceA;
}
int main() {
produce operation = getProduce(3);
cout << "produce = " << operation() << endl; // 通过函数指针,执行对应函数
}
通过指针函数,可以根据一定规则返回对应的函数指针,进而通过函数指针调用对应的函数。