指针的威力(1)--奇妙的函数指针

<<The C programming language>>中指针的定义:
A pointer is a variable that contains the address of a variable.
一针见血的道出了指针的含义,指针也是变量,不过它保存的是其他变量的地址而已.至于这个其他变量是什么,
可能是一个普通build_in类型的变量,可能是一个用户自定义类型的变量,还有,还有...
但一条原则是不会变的:指针指向的实体要么确确实实在内存中存在,要么是NULL.

函数是变量吗?答案否定的.你见过函数被当作一个赋值运算的左值吗?但是函数确确实实是在内存中存在的,不然,我们
通常所说的函数调用是从哪儿调用的呢?函数调用显然是通过找到一个函数的"入口地址"然后在通过这个"入口地址"
进入函数的代码段,执行函数中的指令,然后返回...
当然这里涉及到更多的计算机系统结构方面的知识,这里不再深入.
所以:函数虽然不是变量,但可以定义指向函数的指针,这个指针保存的就是函数的"入口地址".这个"函数的指针"可以
像其他指针一样,被赋值,被放置到数组中,被传递给函数,从函数中返回.

下面就让我们来见证"函数指针"的威力吧:

1.简单示例:

#include <stdio.h>

void func(void)
{
     printf("Test function pointer!\n");
};

typedef void (*PF)(void);

int main(void)
{
    func();
    PF funcp = func;
    funcp();
    return 0;
}

这里使用了一个小技巧:
typedef void (*PF)(void);
在程序中凡是遇到PF,表示的都是一个指向 void (*)(void)类型函数的指针.

显然,上面程序中func() 和 funcp() 的输出结果是相同的.

2.进阶应用--将函数指针传递给函数:
将函数指针传递给另外一个函数,以实现一个在这个"另外函数"中实现对这个函数指针所指向
的函数的调用,这听起来是不是有些绕口?不就是一个函数调用另外一个函数吗?
确实,传递给函数的函数指针确实是用来函数调用的,但这里的函数调用却和普通的函数调用
存在着一些差别.废话少说,上代码:

下面是<<The C programming language>>中通过函数指针传递来实现的对一组记录进行排序的代码:

#include <stdio.h>
#include <stdlib.h>
#include <ctype.h>
#include <string.h>

using namespace std;

#define MAXLINE 1000       /* 用户输入的每行最多有1000个字符 */
#define MAXLINES 5000      /* 用户最大的输入行数  */

char *lineptr[MAXLINES];   /* the pointers point to all lines */

int mygetline(char *line,int max);
int readlines(char *lineptr[],int nlines);
void writelines(char *lineptr[],int nlines);

void qsort(void *lineptr[],int left,int right,int (*comp)(void *,void *));
int numcmp(char *,char *);
int mystrcmp(char *,char *);
void swap(void *v[],int i,int j);

/* sort the input lines */
int main(int argc,char *argv[])
{
    int nlines;
    int numeric = 0;  /* 1 when use numeric sort */

    if(argc > 1 && strcmp(argv[1],"-n") == 0)  numeric = 1;
        if((nlines = readlines(lineptr,MAXLINES)) >= 0)
    {
        qsort((void **)lineptr,0,nlines-1,(int (*)(void *,void *))(numeric ? numcmp : mystrcmp));
            writelines(lineptr,nlines);
    }
    else
        {
            printf("input too big to sort!\n");
        return 1;
    }
        return 0;
}

void qsort(void *v[],int left,int right,int (*cmp)(void *,void *))
{
        int i,last;
        void swap(void *v[],int ,int);

            if(left >= right)
           return;
        swap(v,left,(left+right)/2);
            last = left;

            for(i=left+1;i<=right;i++)
        if((*cmp)(v[i],v[left]) < 0)
            swap(v,++last,i);
                swap(v,left,last);
        qsort(v,left,last-1,cmp);
        qsort(v,last+1,right,cmp);
}

int readlines(char *lineptr[],int maxlines)
{
        int len,nlines;
        char *p,line[MAXLINE];
            nlines = 0;

            while((len = mygetline(line,MAXLINE)) > 0)
           if(nlines >= maxlines || (p=(char *)malloc(sizeof(char)*len)) == NULL)
               return -1;
           else
               {
               line[len-1] = '\0';
               strcpy(p,line);
               lineptr[nlines++] = p;
               return nlines;
           }
}

void writelines(char *lineptr[],int nlines)
{
        int i;
        for(i=0;i<nlines;i++)
            printf("%s\n",lineptr[i]);
}

void swap(void *v[],int i,int j)
{
     void *temp;

     temp = v[i];
     v[i] = v[j];
     v[j] = temp;
}

int numcmp(char *s1,char *s2)
{
     double v1,v2;

     v1 = atof(s1);
     v2 = atof(s2);

     if(v1 < v2)
    return -1;
     else if(v1 > v2)
        return 1;
     else
        return 0;
}

int mystrcmp(char *s1,char *s2)
{
     return strcmp(s1,s2);
}

int mygetline(char *line,int max)
{
    int c,i;

    i=0;
    while(--max > 0 && (c=getchar()) != EOF && c!='\n')
          line[i++] = c;
    if(c == '\n')
    line[i++] = '\0';
    return i;
}

这段代码看起来有些冗长,初看确实是毫无头绪.但只要抓住一点:
这段代码通过函数指针实现了两种不同的排序策略:
     1.根据字母表的顺序排列
     2.根据数值顺序排列
这两种排序策略是怎么实现的呢?

请看qsort(快速排序)
void qsort(void *lineptr[],int left,int right,int (*comp)(void *,void *));
最后一个形参被声明为一个函数指针,main函数中对qsort调用的语句:
qsort((void **)lineptr,0,nlines-1,(int (*)(void *,void *))(numeric ? numcmp : mystrcmp));
当numeric==1时,将函数numcmp传递给qsort,并执行必要的类型转换,因为qsort只接受
int (*)(void *,void *)类型的参数,这是就实现了按数值顺序排序;
当numeric==0时,将函数mystrcmp传递给qsort,实现按字母表顺序的排序;

那么有人会问,这样做有何意义?还不如写两个不同的qsort,一个实现按字母表顺序排序,一个实现按数值顺序
排列.当然,当排序策略很少时,这样做也未尝不可.当有很多种排序策略时,我们难道还要为每一种排序策略
写一个排序函数吗?不要重复发明轮子,记住这一点.一个函数,多种策略.这是函数指针带来的优势.
看到这里,你会想到什么?是不是和C++中的泛型有些相似?模板函数和模板类,一个定义适用与不同的类型.
对,我们后面再讨论函数指针另外一些功用.

再来看一个函数指针的应用--链表的定义:

#include <stdlib.h>

/* Define a struct for linked list elements */
typedef struct ListElmt_
{
     void *data;
     struct ListElmt_ *next;
}ListElmt;

/* Define a structure for linked lists */
typedef struct List_
{
     int size;
     int (*match)(const void *key1,const void *key2);
     void (*destroy)(void *data);
     ListElmt *head;
     ListElmt *tail;
}List;

/* Public Interface */
void list_init(List *list,void (*destroy)(void *data));
void list_destroy(List *list);
int list_ins_next(List *list,ListElmt *element,const void *data);
int list_rem_next(List *list,ListElmt *element,void **data);

#define list_size(list) ((list)->size)

#define list_head(list) ((list)->head)
#define list_tail(list) ((list)->tail)
#define list_is_head(list,element) ((element) == (list)->head ? 1 : 0)
#define list_is_tail(list,element) ((element)->next == NULL ? 1 : 0)
#define list_data(element) ((element)->data)
#define list_next(element) ((element)->next)

上面这段代码是一个链表定义的头文件,注意表示链表的结构体中:
int (*match)(const void *key1,const void *key2);
void (*destroy)(void *data);
match指针指向一个int (*)(const void *,const void *)类型的函数,这个函数用来实现
链表中任意两个元素的比较,可以根据链表元素的类型来定义不同的比较函数.

比如说一个链表中的元素的类型是int型的,即ListElmt结构体中的void *data实际上指向的是一个int
类型变量的地址,那么我们就可以定义一个函数:
int intcmpare(const void *key1,const void *key2)
{
    if (*(const int *)key1 > *(const int*)key2)
            return 1;
    else if(*(const int *)key1 < *(const int*)key2)
        return -1;
    else
            return 0;
}

在定义链表时:
  List mylist;
  mylist.match = intcmpare;
这样mylist这个链表在对元素的比较时就可以实现intcmpare中定义的比较;

另外List结构中还有一个函数指针:destroy.
这个指针可以让我们自定义一个销毁链表元素的函数,是不是和C++类中的析构函数有些相似;
至于C++中类的实现策略和析构函数的实现方法,这不再本文的讨论范围.

3.真正见识函数指针的威力: 函数指针数组
所谓指针数组,就是数组元素是指针的数组.函数指针也是指针,那么当然就存在函数指针数组.
这样的数组中每个元素都指向一个特定的函数,可以将这个数组当成一个函数跳转表.当我们想
跳转到某个特定的函数,去执行某个特定的功能时,使用这个数组是不是特别方便.

试想一下,如果我们的程序的某一个模块下有一系列的功能函数,每个函数虽然功能不同,但接口相似.
我们就可以将这一系列函数的地址放入一个函数指针数组中,这样是不是大大方便了我们的管理呢?

下面请看一个实例,from :<<The C++ programming language>>
假设现在要实现一个编辑器软件,系统的一些功能可以通过函数指针数组来组织:
typedef void(*PF)();

//edit operations
PF edit_ops[] =
{
    &cut,&paste,&copy,&search
};

//file operations
PF file_ops[] =
{
    &open,&append,&close,&write
};

这样我们的软件上就可以有两个按扭:
PF *button1 = edit_ops;
PF *button2 = file_ops;
button1的功能是编辑操作,button2的功能是文件操作;

当然,函数指针的用处还很多,上面只是列举了一些常见的应用.

至于一些更加巧妙的应用, 以后慢慢道来.