22.8  函数类型和函数指针类型

在C语言中，函数也是一种类型，可以定义指向函数的指针。我们知道，指针变量的内存单元里存放一个地址值，而函数指针的内存单元里存放的就是函数的入口地址（位于.text段）。下面看一个简单的例子：

例22.3  函数指针

#include <stdio.h> 
 
void say_hello(const char *str)  
{  
        printf("Hello %s\n", str);  
}  
 
int main(void)  
{  
        void (*f)(const char *) = say_hello;  
        f("Guys");  
        return 0;  
} 

分析一下变量f的类型声明void (*f)(const char *)，f首先跟*号结合在一起，因此是一个指针。(*f)外面是一个函数原型的格式，参数是const char *，返回值是void，所以f是指向这种函数的指针。而say_hello函数的参数是const char *，返回值是void，正好是这种函数，因此f可以指向say_hello函数。注意，表达式say_hello是一种函数类型，函数类型和数组类型相似，做右值使用时自动转换成函数指针类型，因此可以直接赋给f，也可以写成void (*f)(const char *) = &say_hello;，把函数say_hello先取地址再赋给f，就不需要自动类型转换了。

数组取下标运算符[]要求操作数是指针类型，a[1]等价于*(a+1)，如果a是数组类型则要自动转换成指向首元素的指针类型。同样道理，函数调用运算符()要求操作数是函数指针类型，所以f("Guys")是最直接的写法，而say_hello("Guys")或(*f)("Guys")则是把函数类型自动转换成函数指针类型然后做函数调用。

下面再举几个例子区分函数类型和函数指针类型。首先定义函数类型F：

typedef int F(void); 

这种类型的函数不带参数，返回值是int。那么可以这样声明f和g：

F f, g; 

int f(void);  
int g(void); 

F h(void); 

F *e(void); 

F *((e))(void); 

int (*fp)(void); 

F *fp; 

typedef int (*FP)(void); 

((FP)0x12345678)();  
(*(FP)0x12345678)(); 

((int (*)(void))0x12345678)();  
(*(int (*)(void))0x12345678)(); 

#include <stdio.h> 
 
void hello(void)  
{}  
 
int main(void)  
{  
        void (*hello_ptr)(void);  
 
        printf("hello: %p\n", hello); /* function type as rvalue */  
        printf("&hello: %p\n", &hello); /* function type as lvalue */  
        printf("*hello: %p\n", *hello); /* function type as rvalue */  
 
        hellohello_ptr = hello;  
        printf("hellohello_ptr = hello;\n");  
 
        printf("hello_ptr: %p\n", hello_ptr); /* value of a 
function            pointer */  
        printf("&hello_ptr: %p\n", &hello_ptr); /* address 
of a                 function pointer */  
        printf("*hello_ptr: %p\n", *hello_ptr); /* 
dereference a f          unction pointer */  
 
        return 0;  
} 

通过函数指针调用函数和通过函数名直接调用函数相比有什么好处呢？我们研究一个例子。回顾第 7.3 节的习题1，由于结构体中多了一个类型字段，需要重新实现real_part、img_part、magnitude、angle这些函数，你当时是怎么实现的？大概是这样吧：

double real_part(struct complex_struct z)  
{  
        if (z.t == RECTANGULAR)  
                return z.a;  
        else  
                return z.a * cos(z.b);  
} 

现在类型字段有两种取值，RECTANGULAR和POLAR，每个函数都要用if ... else ...分别处理两种情况。如果类型字段有三种取值呢？每个函数都要有if ... else if ... else ...，或者switch ... case ...。这样维护代码是不够理想的，现在我用函数指针给出一种实现：

double rect_real_part(struct complex_struct z)  
{  
        return z.a;  
}  
 
double rect_img_part(struct complex_struct z)  
{  
        return z.b;  
}  
 
double rect_magnitude(struct complex_struct z)  
{  
        return sqrt(z.a * z.a + z.b * z.b);  
}  
 
double rect_angle(struct complex_struct z)  
{  
        double PI = acos(-1.0);  
 
        if (z.a > 0)  
                return atan(z.b / z.a);  
        else  
                return atan(z.b / z.a) + PI;  
}  
 
double pol_real_part(struct complex_struct z)  
{  
        return z.a * cos(z.b);  
}  
 
double pol_img_part(struct complex_struct z)  
{  
        return z.a * sin(z.b);  
}  
 
double pol_magnitude(struct complex_struct z)  
{  
        return z.a;  
}  
 
double pol_angle(struct complex_struct z)  
{  
        return z.b;  
}  
 
double (*real_part_tbl[])(struct complex_struct) =
{ rect_real_         part, pol_real_part };  
double (*img_part_tbl[])(struct complex_struct) =
{ rect_img_part,  pol_img_part };  
double (*magnitude_tbl[])(struct complex_struct)
=  { rect_magnitude, pol_magnitude };  
double (*angle_tbl[])(struct complex_struct) = { rect_angle,    pol_angle };  
 
#define real_part(z) real_part_tbl[z.t](z)  
#define img_part(z) img_part_tbl[z.t](z)  
#define magnitude(z) magnitude_tbl[z.t](z)  
#define angle(z) angle_tbl[z.t](z) 

当调用real_part(z)时，用类型字段z.t做索引，从指针数组real_part_tbl中取出相应的函数指针来调用，也可以达到if ... else ...的效果。相比之下这种实现更好，每个函数都只做一件事情，而不必用if ... else ...兼顾好几件事情，比如rect_real_part和pol_real_part各做各的，互相独立，而不必把它们的代码都耦合到一个函数中。"低耦合，高内聚"（Low Coupling, High Cohesion）是程序设计的一条基本原则，这样可以更好地复用现有代码，更容易维护。如果类型字段z.t又多了一种取值，只需要添加一组新的函数，修改函数指针数组，原有的函数仍然可以不加改动地复用。

另外，这种实现用数据（函数指针数组）取代了代码（if ... else ...），和例 8.4有异曲同工之处，也是应用了Data-driven Programming的思想。