怎样定义函数指针数组

分析：函数指针数组是一个其元素是函数指针的数组。那么也就是说，此数据结构是是一个数组，且其元素是一个指向函数入口地址的指针。
根据分析：首先说明是一个数组：数组名[]
其次，要说明其元素的数据类型指针:数组名[]
再
次，要明确这每一个数组元素是指向函数入口地址的指针：函数返回值类型
(数组名[])()请注意，这里为什么要把“数组名[]”用括号扩起来呢？因为圆括号和数组说明符的优先级是等同的，如果不用圆括号把指针数组说明
表达式扩起来，根据圆括号和方括号的结合方向，那么 数组名[]()
说明的是什么呢？是元素返回值类型为指针的函数数组。有这样的函数数祖吗？不知道。所以必须括起来，以保证数组的每一个元素是指针。

int (p)();这是函数指针，int A（），这是函数，p=A或p=&A都行（这是一个很神奇的地方），
同理，指针数组就是int (p[])(); 他的指向和前面一样，你让他指向一个函数就行了，像其他数组用法一样，至于使用也是很神奇的，你可以用p（），也可以用(p)（）。 这些比较奇怪的问题你可以看那些比较有名的书籍,比如C和指针,或C专家编程之类的

#include <stdioh>
#include <stdlibh>
void sort(int [], const int, int ()(int, int));
void swap(int, int);
int ascending(int, int);
int descending(int, int);
int main()
{
int i,n,p;
printf("input n:");
scanf("%d",&n);
p=(int)malloc(nsizeof(int));
if(!p){printf("malloc err");exit(0);}
printf("input %d number:\n",n);
for(i=0;i<n;i++)scanf("%d",p+i);
printf("1:ascending\n2:descending\n");
scanf("%d",&i);
if(i==1)sort(p,n,ascending);
if(i==2)sort(p,n,descending);
for(i=0;i<n;i++)printf("%d ",p[i]);
return 0;
}
void sort(int items[], const int count, int (cmp)(int, int))
//没看清,之前是冒泡,不是选择
{
int a,b,c,exchange,t;
for(a=0;a<count-1;++a)
{
exchange=0;
c=a;
t=items[a];
for(b=a+1;b<count;++b)
{
if(cmp(t,items[b]))
{
c=b;
t=items[c];
exchange=1;
}
}
if(exchange)swap(&items[c],&items[a]);
}
}
void swap(int a,int b)
{
int t=a;
a=b;
b=t;
}
int ascending(int a, int b)
{
if(a>b)return 1;
return 0;
}
int descending(int a, int b)
{
if(a<b)return 1;
return 0;
}

我想这篇文章更有助于学习！
深入理解C/C++函数指针
笔者在开发某软件过程中遇到这样一个问题，前级模块传给我二进制数据，输入参数为 char buffer和 int length，buffer是数据的首地址，length表示这批数据的长度。数据的特点是：长度不定，类型不定，由第一个字节（buffer[0]）标识该数据的类型，共有256（28 ）种可能性。我的任务是必须对每一种可能出现的数据类型都要作处理，并且我的模块包含若干个函数，在每个函数里面都要作类似的处理。若按通常做法，会写出如下代码：
void MyFuntion( char buffer, int length )
{
__int8 nStreamType = buffer[0];
switch( nStreamType )
{
case 0:
function1();
break;
case 1:

case 255:
function255();
break;
}
}
如果按照这种方法写下去，那么在我的每一个函数里面，都必须作如此多的判断，写出的代码肯定很长，并且每一次处理，都要作许多次判断之后才找到正确的处理函数，代码的执行效率也不高。针对上述问题，我想到了用函数指针数组的方法解决这个问题。
函数指针的概念，在潭浩强先生的C语言程序设计这本经典的教程中提及过，在大多数情况下我们使用不到，也忽略了它的存在。函数名实际上也是一种指针，指向函数的入口地址，但它又不同于普通的如int、double指针，看下面的例子来理解函数指针的概念：
int funtion( int x, int y );
void main ( void )
{
int (fun) ( int x, int y );
int a = 10, b = 20;
function( a, b );
fun = function;
(fun)( a, b );
……
}
语句1定义了一个函数function，其输入为两个整型数，返回也为一个整型数（输入参数和返回值可为其它任何数据类型）；语句3定义了一个函数指针，与int或double定义指针不同的是，函数指针的定义必须同时指出输入参数，表明这是一个函数指针，并且fun也必须用一对括号括起来；语句6将函数指针赋值为funtion，前提条件是fun和function的输入参数和返回值必须保持一致。语句5直接调用函数function（），语句7是调用函数指针，二者等效。
当然从上述例子看不出函数指针的优点，目的主要是想引出函数指针数组的概念。我们从上面例子可以得知，既然函数名可以通过函数指针加以保存，那们也一定能定义一个数组保存若干个函数名，这就是函数指针数组。正确使用函数指针数组的前提条件是，这若干个需要通过函数指针数组保存的函数必须有相同的输入、输出值。
这样，我工作中所面临的问题可以解决如下：
首先定义256个处理函数(及其实现)。
void funtion0( void );
……
void funtion255(void );
其次定义函数指针数组，并给数组赋值。
void (fun[256])(void);
fun[0] = function0;
……
fun[255] = function();
最后，MyFunction()函数可以修改如下：
void MyFuntion( char buffer, int length )
{
__int8 nStreamType = buffer[0];
(fun[nStreamType])();
}
只要2行代码，就完成了256条case语句要做的事，减少了编写代码时工作量，将nStreamType作为数组下标，直接调用函数指针，从代码执行效率上来说，也比case语句高。假如多个函数中均要作如此处理，函数指针数组更能体现出它的优势。
函数指针与typedef
关于C++中函数指针的使用(包含对typedef用法的讨论)
(一)简单的函数指针的应用。
//形式1：返回类型(函数名)(参数表)
char (pFun)(int);
char glFun(int a){ return;}
void main()
{
pFun = glFun;
(pFun)(2);
}
第一行定义了一个指针变量pFun。首先我们根据前面提到的“形式1”认识到它是一个指向某种函数的指针，这种函数参数是一个int型，返回值是char类型。只有第一句我们还无法使用这个指针，因为我们还未对它进行赋值。
第二行定义了一个函数glFun()。该函数正好是一个以int为参数返回char的函数。我们要从指针的层次上理解函数——函数的函数名实际上就是一个指针，函数名指向该函数的代码在内存中的首地址。
然后就是可爱的main()函数了，它的第一句您应该看得懂了——它将函数glFun的地址赋值给变量pFun。main()函数的第二句中“pFun”显然是取pFun所指向地址的内容，当然也就是取出了函数glFun()的内容，然后给定参数为2。
(二)使用typedef更直观更方便。
//形式2：typedef 返回类型(新类型)(参数表)
typedef char (PTRFUN)(int);
PTRFUN pFun;
char glFun(int a){ return;}
void main()
{
pFun = glFun;
(pFun)(2);
}
typedef的功能是定义新的类型。第一句就是定义了一种PTRFUN的类型，并定义这种类型为指向某种函数的指针，这种函数以一个int为参数并返回char类型。后面就可以像使用int,char一样使用PTRFUN了。
第二行的代码便使用这个新类型定义了变量pFun，此时就可以像使用形式1一样使用这个变量了。
(三)在C++类中使用函数指针。
//形式3：typedef 返回类型(类名::新类型)(参数表)
class CA
{
public:
char lcFun(int a){ return; }
};
CA ca;
typedef char (CA::PTRFUN)(int);
PTRFUN pFun;
void main()
{
pFun = CA::lcFun;
ca(pFun)(2);
}
在这里，指针的定义与使用都加上了“类限制”或“对象”，用来指明指针指向的函数是哪个类的,这里的类对象也可以是使用new得到的。比如：
CA pca = new CA;
pca->(pFun)(2);
delete pca;
而且这个类对象指针可以是类内部成员变量，你甚至可以使用this指针。比如：
类CA有成员变量PTRFUN m_pfun;
void CA::lcFun2()
{
(this->m_pFun)(2);
}
一句话，使用类成员函数指针必须有“->”或“”的调用。
在调用动态库时，习惯用typedef重新定义动态库函数中的函数地址（函数指针），如在动态库（testdll）中有如下函数：
int DoCase(int, long);
则，在调用动态库是有两种方法：
1 先声明一个与动态库中类型一致的指针函数变量：
int (DOCASE)(int ,long);//用于指向动态库中的DoCase函数地址
HINSTANCE gLibMyDLL = NULL;
gLibMyDLL = LoadLibrary("testdll");
if(gLibMyDLL != NULL)
{
//得到函数地址
DOCASE = (int()(int,long))GetProcAddress(gLibMyDLL, "DoCase");
}
//调用函数
int s = DOCASE(1,1000);
2用typedef定义一个指针函数：typedef (DOCASE)(int ,long);
HINSTANCE gLibMyDLL = NULL;
DOCASE _docase;
gLibMyDLL = LoadLibrary("testdll");
if(gLibMyDLL != NULL)
{
_docase = (DOCASE)GetProcAddress(gLibMyDll, "DoCase");
}
//调用函数
int s=_docase(1,1000);

指针数组是指针的数组，把这句话重复三遍
这个数组里放的满满的都是指针
数组指针是一个指针，这个指针指向一个数组
同理函数指针指向一个函数，只是个变量
指针函数是指带指针的函数，即本质是一个函数
int f(x，y);
是很绕人

这个问题很有趣，要理解有个前提，你至少要思考过数组怎样在内存中存储，并且一个字节一个字节地画过。
无论数组指针，还是指针数组，这样的名词性短语重心都在后面，所以数组指针是个指针，指针数组是个数组。
数组指针的实例：int(p)[5]; 可以这样解释其定义：p是个指针，指向一个数组，数组有5个元素，每个元素是一个int型整数。在内存中，p就是一个占4字节的变量，变量的值是个地址，在内存的那个地址处，有45＝20个连续字节被认为是一个int[5]数组。做一次p++，p的值增加20。这种特性和二维数组是有相似之处的，比如int k[3][5]，事实上，可以这样赋值： p=k。 如果要在形参里使用，可以将变量名去除，就抽象出数据类型。典型的函数声明可以这样写：void f( int()[5] ); 典型的实参调用可以这样写：f(k); 这里的k是int k[3][5]二维数组。我印象里要把二维数组名作实参使用，形参只能写成数组指针，形参直接写成二维数组是不行的，void f( int [3][5]);这样声明会报错。也不能写void f( int ); 因为int和intint()[5]是不同的，前者做++只增4，后者增20。

指针数组的实例：intp[5]; 这样解释：p是个数组，数组有5个元素，每个元素是一个指针，指向一个int型整数。这里p是数组名，是指针常量而不是变量，不可以对p赋值，这和上面比，是本质区别。从内存占用情况来看，他和int p[5]没啥区别，每个元素都占4字节。所以使用时可以参考整型数组，只要把int替换成int就行了。比如声明时可用void f( int[5] );，也可用void f( int );。调用实参时，就把实际的指针数组名传入即可，比如f(t);，这里t是 intt[5]。

这点篇幅其实是说不完的，书里都用一整章来讲呢。还是开头说的，研究一下数组及指针在内存里怎样存储，一个字节一个字节画一画，有好处。

---