C++笔记：关于函数指针

函数指针定义

普通函数指针

函数指针可以理解为指向该类型函数的指针

• 函数指针定义：返回值类型 （*函数指针名）（参数列表）。如：int (*fp)(int a)

该段代码定义了一个函数指针，该指针可以用于指向返回值类型为int，只有一个int类型参数的函数。

• 函数指针赋值：函数指针赋值有两种方式
  1. 直接赋值：函数指针 = 函数名
  2. 取地址符赋值：函数指针 = &函数名
• 调用：函数指针的使用方式和普通函数调用别无二致

例子如下：

#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 = &类名::函数名；

• 调用：成员函数指针有两种调用方式，一种是通过类实例调用：.指针名，一种是通过指针调用：->指针名

  1. 通过实例调用：(类对象.*指针名)(参数列表);

  2. 通过指针调用：(类指针->*指针名)(参数列表);

     在这里的调用中，如果没有前面的括号，按照操作赋的优先级，括号优先于.操作符，类似于类对象.*指针名(参数列表)的表达式将会报错。

实例如下：

#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);

该例子初一看，比较复杂。根据前面说的符号的优先级解读：

1. (func(int)表明func是一个函数。
2. (*(func(int)))中的*表明func的返回值是一个指针。
3. 最后的(int a)表明该指针是一个函数。
4. 返回值中的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; // 通过函数指针，执行对应函数
}

通过指针函数，可以根据一定规则返回对应的函数指针，进而通过函数指针调用对应的函数。