数组,指针数组,数组指针,函数指针数组,函数指针数组的指针

 1 代码

 2 

 3 Code highlighting produced by Actipro CodeHighlighter (freeware)http://www.CodeHighlighter.com/-->//数组

 4 void test()

 5 {    

 6     //数组

 7     int a[100];

 8 

 9     //指针数组,包含100个int*的数组

10     int* a[100];

11 

12     //数组指针,指向一个包含100个int类型的数组的指针

13     int (*a)[100];

14 

15     //函数指针1,指向一个原型为void fun()的指针

16     void (*fp)();

17 

18     //函数指针2,指向一个原型为char fun(char* p1,char* p2)的指针

19     char* (*fp)(char* p1,char* p2);

20 

21     //函数指针数组1,声明了一个数组,数组名为fp,数组内存储了100个执行函数原型为void fun()的指针

22     void (*fp[100])();

23 

24     //函数指针数组2,声明了一个数组,数组名为fp,数组内存储了100个执行函数原型为char fun(char* p1,char* p2)的指针

25     char* (*fp[100])(char* p1,char* p2);

26 

27     //函数指针数组的指针1,指向一个包含数组内存储了100个执行函数原型为void fun()的指针

28     void (*(*fp)[100])();

29 

30     //函数指针数组的指针2,指向一个包含数组内存储了100个执行函数原型为char fun(char* p1,char* p2)的指针

31     char* (*(*fp)[100])(char* p1,char* p2);

32 

33 }

--------------指针---------------- int a=10; int *p=&a;

-------------指针的指针----------- int b=20; int *p=&b; int **p2p=&p;

-------------简单数组----------------- int c[10];//整数数组，含有10个整数元素 也就是说每一个元素都是整数
--------------指针数组-------------------- int *p[10];//指针数组，含有10个指针元素 也就是说每一个元素都是指针
--------------数组指针-------------------- int (*p)[10];//数组指针，这个指针能够用来指向 含有10个元素的整数数组

 

------------函数指针---------------------

int (*p)( ); // 指向函数的指针...这里声明了一个指针p，该指针指向返回值是整型（即函数类型为整型）的函数！

----------------指针函数---------------------------

int *p(int a,float b); //返回值为指针的函数...该函数返回指向整型变量的指针！

即该函数的类型为int *, p和上例不同，他是函数名！上例中是指针！

===========================================================================

C/C 中函数指针的含义

作者：管宁

　　函数存放在内存的代码区域内，他们同样有地址，我们如何能获得函数的地址呢？
　　假如我们有一个int test(int a)的函数，那么，他的地址就是函数的名字，这一点如同数组相同，数组的名字就是数组的起始地址。

　　定义一个指向函数的指针用如下的形式，以上面的test()为例：

int (*fp)(int a);//这里就定义了一个指向函数的指针

　　函数指针不能绝对不能指向不同类型，或是带不同形参的函数，在定义函数指针的时候我们很容易犯如下的错误。

int *fp(int a);//这里是错误的，因为按照结合性和优先级来看就是先和()结合，然后变成了一个返回整形指针的函数了，而不是函数指针，这一点尤其需要注意！

　　下面我们来看一个具体的例子：

#include <iostream> #include <string> using namespace std;
int test(int a);
void main(int argc,char* argv[]) { cout<<test<<endl;//显示函数地址 int (*fp)(int a); fp=test;//将函数test的地址赋给函数学指针fp cout<<fp(5)<<"|"<<(*fp)(10)<<endl; //上面的输出fp(5),这是标准c 的写法,(*fp)(10)这是兼容c语言的标准写法,两种同意,但注意区分,避免写的程式产生移植性问题! cin.get(); }
int test(int a) { return a; }

　　typedef定义能够简化函数指针的定义，在定义一个的时候感觉不出来，但定义多了就知道方便了，上面的代码改写成如下的形式：

#include <iostream> #include <string> using namespace std;
int test(int a);
void main(int argc,char* argv[]) { cout<<test<<endl; typedef int (*fp)(int a);//注意,这里不是生命函数指针,而是定义一个函数指针的类型,这个类型是自己定义的,类型名为fp fp fpi;//这里利用自己定义的类型名fp定义了一个fpi的函数指针! fpi=test; cout<<fpi(5)<<"|"<<(*fpi)(10)<<endl; cin.get(); }
int test(int a) { return a; }

　　函数指针同样是能够作为参数传递给函数的，下面我们看个例子，仔细阅读您将会发现他的用处，稍加推理能够很方便我们进行一些复杂的编程工作。

//-------------------该例以上一个例子作为基础稍加了修改----------------------------- #include <iostream> #include <string> using namespace std;
int test(int);
int test2(int (*ra)(int ,int);
void main(int argc,char* argv[]) { cout<<test<<endl; typedef int (*fp)(int); fp fpi; fpi=test;//fpi赋予test 函数的内存地址
cout<<test2(fpi,1)<<endl;//这里调用test2函数的时候,这里把fpi所存储的函数地址(test的函数地址)传递了给test2的第一个形参 cin.get(); }
int test(int a) { return a-1; }
int test2(int (*ra)(int),int b)//这里定义了一个名字为ra的函数指针 { int c=ra(10) b;//在调用之后,ra已指向fpi所指向的函数地址即test函数 return c; }

 

　　利用函数指针，我们能够构成指针数组，更明确点的说法是构成指向函数的指针数组，这么说可能就容易理解的多了。

#include <iostream> #include <string> using namespace std;
void t1(){cout<<"test1";} void t2(){cout<<"test2";} void t3(){cout<<"test3";} void main(int argc,char* argv[]) { void* a[]={t1,t2,t3}; cout<<"比较t1()的内存地址和数组a[0]所存储的地址是否一致"<<t1<<"|"<<a[0]<<endl;
cout<<a[0]();//错误!指针数组是不能利用数组下标操作调用函数的
typedef void (*fp)();//自定义一个函数指针类型 fp b[]={t1,t2,t3}; //利用自定义类型fp把b[]定义趁一个指向函数的指针数组 b[0]();//现在利用指向函数的指针数组进行下标操作就能够进行函数的间接调用了; cin.get(); }

　　仔细看上面的例子可能不用我多说大家也会知道是怎么一会事情了,最后我们做一个重点小结,只要记住这一点,对于理解利用函数指针构成数组进行函数间接调用就很容易了!

void* a[]={t1,t2,t3}; cout<<"比较t1()的内存地址和数组a[0]所存储的地址是否一致"<<t1<<"|"<<a[0]<<endl;
cout<<a[0]();//错误!指针数组是不能利用数组下标操作调用函数的

　　上面的这一小段中的错误行，为什么不能这么调用呢？
　　前一篇教程我们已说的很清楚了，但是在这里我们还是复习一下概念，指针数组元素所保存的只是个内存地址，既然只是个内存地址就不可能进行a[0]()这样地址带括号的操作，而函数指针不同他是个例外，函数指针只所以这么叫他就是因为他是指向函数指向内存的代码区的指针，他被系统授予允许和()括号操作的权利，进行间接的函数调用，既然函数指针允许这么操作，那么被定义成函数指针的数组就一定是能够相同的操作的。

《转自：http://www.pconline.com.cn/pcedu/empolder/gj/c/0503/566020