我曾经写过一个命令行程序,有很多命令,于是构着了一个结构的数组,大概是这样 struct{ char *cmd_name; bool (*cmd_fun)(); }cmd_info_list[MAX_CMD_NUM]; 程序中得到一个用户输入的命令字符串后,就匹配这个数组,找到对应的处理函数。 以后每次添加一个命令,只需要加个函数,然后在这个数组中加一个记录就可以了,不需要修改太多的代码。 这可以算是一种用法吧。呵呵。 Windows 中,窗口的回调函数就用到了函数指针。 用VC向导 New Projects ----> Win32 Application ----> A typical "Hello World!" application 其中的WndProc 是WNDPROC 类型的函数typedef LRESULT (CALLBACK* WNDPROC)(HWND, UINT, WPARAM, LPARAM); WndProc 作为窗口的回调函数,用来填充WNDCLASSEX 结构。 WNDCLASSEX wcex; wcex.lpfnWndProc = (WNDPROC)WndProc; void ListTraverse(LinkList L,void (*visit)(int)) { Link p; p=L->next; while(p) { visit(p->data); p=p->next; } return OK; } void print(int c) { printf("%d",c); } ListTraverse(L,print); 这算是个例子吧??? #include #include #include double Add (double x, double y) { return x+y; } double Sub (double x, double y) { return x-y; } double Mul (double x, double y)
函数指针的使用方法
对指针的应用是C语言编程的精髓所在,而回调函数就是C语言里面对函数指针的高级应用。简而言之,回调函数是一个通过函数指针调用的函数。如果你把函数指针(函数的入口地址)传递给另一个函数,当这个函数指针被用来调用它所指向的函数时,我们就说这个函数是回调函数。 为什么要使用回调函数呢?我们先看一个小例子: Node * Search_List (Node * node, const int value) { while (node != NULL) { if (node -> value == value) { break; } node = node -> next; } return node; } 这个函数用于在一个单向链表中查找一个指定的值,返回保存这个值的节点。它的参数是指向这个链表第一个节点的指针以及要查找的值。这个函数看上去很简单,但是我们考虑一个问题:它只能适用于值为整数的链表,如果查找一个字符串链表,我们不得不再写一个函数,其实大部分代码和现在这个函数相同,只是第二个参数的类型和比较的方法不同。 其实我们更希望令查找函数与类型无关,这样它就能用于查找存放任何类型值的链表了,因此必须改变比较的方式,而借助回调函数就可以达到这个目的。我们编写一个函数(回调函数),用于比较两个同类型的值,然后把一个指向这个函数的指针作为参数传递给查找函数,查找函数调用这个比较函数来执行比较,采用这个方法,任何类型的值得都可以进行比较。 我们还必须给查找函数传递一个指向待比较的值的指针而不是值本身,也就是一个void *类型的形参,这个指针会传递给回调函数,进行最终的比较。这样的修改可以让我们传递指向任何类型的指针到查找函数,从而完成对任何类型的比较,这就是指针的好处,我们无法将字符串、数组或者结构体作为参数传递给函数,但是指向它们的指针却可以。 现在,我们的查找函数就可以这样实现: NODE *Search_List(NODE *node, int (*compare)(void const *, void const *) , void const *desired_value); { while (node != NULL) { if (compare((node->value_address), desired_value) == 0) { break; } node = node->next; } return node; }
函数指针和指针函数的理解
我知道函数指针是指向函数的指针,指针函数还是指一个函数的返回值是一个指针,但下面的几道题还是感觉很迷惑。各位能否讲的详细点呢? (1)float(**def)[10]def是什么? (2)double*(*gh)[10]gh是什么? (3)double(*f[10])()f是什么? (4)int*((*b)[10])b是什么? 这样老感觉有点乱,有什么窍门可以记得并理解的清楚一点么? (1)def是一个指针,指向的对象也是一个指针,指向的指针最终指向的是10个float构成的数组. (2)gh是指针,指向的是10个元素构成的数组,数组的元素是double*类型的指针. (3)f是10个元素构成的数组,每个元素是指针,指针指向的是函数,函数类型为无参数且返回值为double.下面要讲的窍门的例子跟这个很类似. (4)b是指针,指向的是10个元素构成的数组,数组元素为int*类型的指针. 窍门如下: 如果我们碰到复杂的类型声明,该如何解析它?例如: char(*a[3])(int); a到底被声明为什么东东?指针?数组?还是函数? 分析时,从a最接近(按运算符优先级)处开始。我们看到a最接近符号是[]——注意:*比[]的优先级低。a后既然有[],那么a是数组,而且是包含3个元素的数组。 那这个数组的每个元素是什么类型呢?虽然数组a只含有a[0]、a[1]、a[2]三个元素,a[3]实际上已经越界,但在分析数组a的元素的类型时,我们正好需要形式上的元素a[3]。知道了a[3]的类型,就知道了a的元素的类型。a[3]是什么类型?是指针,因为它的前面有*.由此可知,数组a的元素是指针。 光说是指针还不够。对于指针,必须说出它指向的东东是什么类型。它指向的东东是什么,就看*a[3]是什么(a[3]是指针,它指向的东东当然是*a[3])了。继续按优先级观察,我们看到*a[3]后面有小括号,所以可以肯定*a[3]是函数。即数组a的元素是指向函数的指针。 指向的是什么类型的函数?这很明显,是入参为int、返回值为char的类型的函数。 至此解析完毕。
C语言学习笔记之函数指针
C/C++学习笔记之函数指针 函数指针的概念,在潭浩强先生的《C语言程序设计》这本经典的教程中提及过,在大多数情况下我们使用不到,也忽略了它的存在。函数名实际上也是一种指针,指向函数的入口地址,但它又不同于普通的如int*、double*指针,看下面的例子来理解函数指针的概念:view plain int function(int x,int y); int main(void) { int(*fun)(int x,int y); int a=10,b=20; function(a,b); fun=function; (*fun)(a,b);…… } 第一行代码首先定义了一个函数function,其输入为两个整型数,返回也为一个整型数(输入参数和返回值可为其它任何数据类型);后面又定义了一个函数指针fun,与int*或double*定义指针不同的是,函数指针的定义必须同时指出输入参数,表明这是一个函数指针,并且*fun也必须用一对括号括起来;并将函数指针赋值为函数function,前提条件是*fun 和function的输入参数和返回值必须保持一致,否则无法通过编译。可以直接调用函数function(),也可以直接调用函数指针,二者是等效的。 回调函数(callback)是一个程序员不能显式调用的函数;通过将回调函数的地址传给调用者从而实现调用。简而言之,回调函数就是一个通过函数指针调用的函数。如果你把函数的指针(地址)作为参数传递给另一个函数,当这个指针被用为调用它所指向的函数时,我们就说这是回调函数。要实现回调,必须首先定义函数指针。尽管定义的语法有点不可思议,但如果你熟悉函数声明的一般方法,便会发现函数指针的声明与函数声明非常类似。请看下面的例子: void f();//函数原型 上面的语句声明了一个函数,没有输入参数并返回void.那么函数指针的声明方法如下:void(*)(); 函数存放在内存的代码区域内,它们同样有地址,我们如何能获得函数的地址呢? 如果我们有一个int test(int a)的函数,那么,它的地址就是函数的名字,这一点如同数组一样,数组的名字就是数组的起始地址。 定义一个指向函数的指针用如下的形式,以上面的test()为例: int(*fp)(int a);//这里就定义了一个指向函数的指针 函数指针绝对不能指向不同类型,或者是带不同形参的函数,在定义函数指针的时候我们很容易犯如下的错误。 int*fp(int a);//这里是错误的,因为按照结合性和优先级来看就是先和()结合,然后变成了一个返回整型指针的函数了,而不是函数指针,这一点尤其需要注意! 例如函数原型为: int fun(int*,int); 则函数指针可以声明为:int(*pf)(int*,int);当然从上述例子看不出函数指针的优点,目的主要是想引出函数指针数组的概念。我们从上面例子可以得知,既然函数名可以通过函数指针加以保存,那们也一定能定义一个数组保存若干个函数名,这就是函数指针数组。正确使用函数指针数组的前提条件是,这若干个需要通过函数指针数组保存的函
Keil C51中函数指针使用注意事项
Keil C51中函数指针使用注意事项 在我们的代码中大量使用了函数指针。当函数指针用在Keil C51中时,一定要注意编译器自动生成的函数调用树通常是不正确的,需要手动调整。否则可能造成无法预知的后果。 这是因为,Keil C51编译器并不把函数参数和局部变量压入堆栈中,而是放在寄存器或固定的内存位置。 C51的编译器监视函数调用的嵌套顺序,把几个函数的变量放在同样固定的位置。在C51编译器中连接器会搜索所有函数中变量占用存储区间最多的函数,然后以这个函数的变量的占用空间开辟一片空间,其他函数的变量也放在该空间中,同时实现了变量的覆盖(无相互调用)与地址的共享。例如函数A占10个字节,函数B占20个字节,函数C占15个字节,如果它们之间没有相互调用则仅需20个字节就可以满足45个字节的变量需要。 正是由于所有函数的参数和局部变量的共享一个覆盖区,函数没有相互的调用时,在执行一个函数时,会将另一个函数的变量的存储区覆盖。如果函数有调用,那么不会覆盖原来函数的局部变量的区间。 调用树(call tree)是由Keil链接器自动生成的,用于描述函数的调用关系(调用树可通过编译生成的*.M51文件的OVERLAY MAP OF MODULE部分查看,该部分详细的说明了函数的调用关系以及对覆盖存储区的使用情况)。链接器通过分析调用树来确定哪些寄存器或内存位置是可安全覆盖的。这样两个不同时调用的函数就可以共享同一块内存用于传递参数和存储局部变量。但对于函数指针来说,编译器并不知道函数指针将指向哪个函数。这导致了调用树构造出错的可能,函数的参数和局部变量也可能被错误覆盖(例如,函数A通过函数指针调用了函数B,但编译器并不知道它们之间存在调用关系,所以认为它们是可以共享同一块内存的。这样当函数A调用了函数B,回到函数A后,函数A的参数和局部变量可能已经被改变了,再往下运行就出错了)。 对此,Keil提供了链接器OVERLAY伪指令,可让用户自行修改调用树,调整函数的调用关系。 删除调用关系,命令格式: OVERLAY (sfname-caller ~ sfname-callee) OVERLAY (sfname-caller ~ (sfname-callee, sfname-callee)) 举例:OVERLAY(?PR?_FUNC?DMAIN ~ (?PR?_FUNC_A?DMAIN,?PR?_FUNC_B?DMAIN)) 意思是从FUNC函数中删除对FUNC_A和FUNC_B的调用。 添加调用关系,命令格式: OVERLAY (sfname-caller ! sfname-callee) OVERLAY (sfname-caller ! (sfname-callee, sfname-callee)) 举例:OVERLAY(?PR?_MAIN?DMAIN ! (?PR?_FUNC_A?DMAIN,?PR?_FUNC_B?DMAIN)) 意思是添加FUNC函数对FUNC_A和FUNC_B的调用。 可在链接命令行输入命令。或在Keil集成开发环境中,在“BL51 Misc”-“Overlay”中填入()中的内容。
函数指针和指针函数
在程序运行中,函数代码是程序的算法指令部分,它们和数组一样也占用存储空间,都有相应的地址。可以使用指针变量指向数组的首地址,也可以使用指针变量指向函数代码的首地址,指向函数代码首地址的指针变量称为函数指针。 1.函数指针定义 函数类型(*指针变量名)(形参列表); “函数类型”说明函数的返回类型,由于“()”的优先级高于“*”,所以指针变量名外的括号必不可少,后面的“形参列表”表示指针变量指向的函数所带的参数列表。 例如: int (*f)(int x); double (*ptr)(double x); 在定义函数指针时请注意: 函数指针和它指向的函数的参数个数和类型都应该是—致的; 函数指针的类型和函数的返回值类型也必须是一致的。 2.函数指针的赋值 函数名和数组名一样代表了函数代码的首地址,因此在赋值时,直接将函数指针指向函数名就行了。 例如, int func(int x); /* 声明一个函数*/ int (*f) (int x); /* 声明一个函数指针*/ f=func; /* 将func函数的首地址赋给指针f */ 赋值时函数func不带括号,也不带参数,由于func代表函数的首地址,
因此经过赋值以后,指针f就指向函数func(x)的代码的首地址。
3.通过函数指针调用函数 函数指针是通过函数名及有关参数进行调用的。 与其他指针变量相类似,如果指针变量pi是指向某整型变量i的指针,则*p等于它所指的变量i;如果pf是指向某浮点型变量f的指针,则*pf 就等价于它所指的变量f。同样地,*f是指向函数func(x)的指针,则*f 就代表它所指向的函数func。所以在执行了f=func;之后,(*f)和func代表同一函数。 由于函数指针指向存储区中的某个函数,因此可以通过函数指针调用相应的函数。现在我们就讨论如何用函数指针调用函数,它应执行下面三步: 首先,要说明函数指针变量。 例如:int (*f)(int x); 其次,要对函数指针变量赋值。 例如:f=func; (func(x)必须先要有定义) 最后,要用(*指针变量)(参数表);调用函数。 例如:(*f)(x);(x必须先赋值) 【例】任意输入n个数,找出其中最大数,并且输出最大数值。 main() { int f(); int i,a,b; int (*p)(); /* 定义函数指针*/ scanf('%d',&a);
实验一 函数-指针及其应用
实验一函数、指针及其应用 (一)函数的基本应用 一、实验目的 1.掌握函数声明、定义及调用的方法。 2.掌握函数实际参数与形式参数的对应关系以及数据的“值传递”方式。 3.掌握递归的思想和递归调用的一般方法。 4.学习编写简单的递归程序。 二、实验内容 1.验证性实验 (1)下列程序的执行结果是什么? #include "stdio.h" void change(int a,int b) { int t; t=a;a=b;b=t; } void main( ) { int x,y; printf("input x,y: "); scanf("%d,%d",&x,&y); change(x,y); printf("x=%d,y=%d\n",x,y); } 思考:为什么x与y的值没有互换? (2)下列程序的执行结果是什么? #include void exam1(int); void exam2(void); int a=0; void main(void) { int a; a=15; printf("a=%d\n",a); exam1(a); printf("a=%d\n",a); exam2( ); printf("a=%d\n",a); } void exam1( int a) { printf("\ta=%d\n",a);
a++; printf("\ta=%d\n",a); } void exam2(void) { printf("\ta=%d\n",a); a++; printf("\ta=%d\n",a); } 2.程序填空 (1)下列程序的功能是输出100~1000之间所有既能被3整除,又能被7整除的数。 #include void main() {int k; int sele(int n); for(k=100;k<=1000;k++) if( ① ) printf("%5d", ② ); printf("\n"); } int sele(int n) { if( ③ ) return (1); return 0 ; } (2)下列程序的功能是:prime()函数用于判别一个数是否为素数,在主函数输入一个整数,输出是否素数的信息。 #include void main() { int number; int prime(int number); printf("请输入一个正整数:\n"); scanf("%d",&number); if (prime(number)) printf("\n %d是素数. ",number); else printf("\n %d不是素数. ",number); } int prime(int num) /*此函数用于判别素数*/
函数名与函数指针-C指针
彻底搞定C指针-函数名与函数指针 函数名与函数指针 一通常的函数调用 一个通常的函数调用的例子: //自行包含头文件 void MyFun(int x); //此处的申明也可写成:void MyFun( int ); int main(int argc, char* argv[]) { MyFun(10); //这里是调用MyFun(10);函数 return 0; } void MyFun(int x) //这里定义一个MyFun函数 { prin tf(“%d\n”,x); } 这个MyFun函数是一个无返回值的函数,它并不完成什么事情。这种调用函数的格式你应该是很熟悉的吧!看主函数中调用MyFun函数的书写格式:MyFun(10); 我们一开始只是从功能上或者说从数学意义上理解MyFun这个函数,知道MyFun函数名代表的是一个功能(或是说一段代码)。 直到—— 学习到函数指针概念时。我才不得不在思考:函数名到底又是什么东西呢? (不要以为这是没有什么意义的事噢!呵呵,继续往下看你就知道了。)二函数指针变量的申明 就象某一数据变量的内存地址可以存储在相应的指针变量中一样,函数的首地址也以存储在某个函数指针变量里的。这样,我就可以通过这个函数指针变量来调用所指向的函数了。 在C系列语言中,任何一个变量,总是要先申明,之后才能使用的。那么,函数指针变量也应该要先申明吧?那又是如何来申明呢?以上面的例子为例,我来申明一个可以指向MyFun函数的函数指针变量FunP。下面就是申明FunP 变量的方法: void (*FunP)(int) ; //也可写成void (*FunP)(int x);
c++指针函数和变量地址做形参的用法
指针函数的用法 1、例:char *getnum(int num,int addr) 字符型指针函数返回值为字符地址。即:return返回指针地址。 例:声明字符型指针char *a。返回值只能写return a;不能写return *a; 也不能写:char a; return a; 会报“cannot convert from 'char' to 'char *'”错误 2、cout<<*getnum(12,addr)< //引用库函数 using namespace std; //使用命名空间 int main() //主函数,程序执行的入口 { cout<<"*********************"<C语言函数指针的几种用法
C语言函数指针的几种用法 Free_Bird 主要参考了:https://www.360docs.net/doc/122189357.html,/space.php?uid=9950859&do=blog&id=98594写的很好;在此感谢高手们的无私; 以下是我编写的一段程序,希望能帮到需要的xdjm; 程序如下: #include #include /*--指针的应用都在主函数里,前面都是准备工作--*/ /*----------------------------------------------------------*/ /*------简单应用指针的前期准备------*/ /*----------------------------------------------------------*/ //声明并定义一个变量、一个数组和一个函数 double R = 0; unsigned char Temp[10] = {9,8,7,6,5,4,3,2,1,0}; void delay_ms(unsigned int n) { unsigned int i,j; for(i = 0; i< n ; i++) { for(j = 0; j < 2280; j++); } } //声明一个指向无符号字符型的指针和一个函数指针 unsigned char *pT; void (*pF)(unsigned int n); /*----------------------------------------------------------*/ /*------应用函数指针的前期准备------*/ /*----------------------------------------------------------*/ /*------相关函数的声明和定义------*/ int add(int a, int b){int sum; sum = a + b; return sum;} int sub(int a, int b){int difference; difference = a - b; return difference;}
函数指针和指针函数
函数指针 在程序运行中,函数代码是程序的算法指令部分,它们和数组一样也占用存储空间,都有相应的地址。可以使用指针变量指向数组的首地址,也可以使用指针变量指向函数代码的首地址,指向函数代码首地址的指针变量称为函数指针。 1.函数指针定义 函数类型(*指针变量名)(形参列表); “函数类型”说明函数的返回类型,由于“()”的优先级高于“*”,所以指针变量名外的括号必不可少,后面的“形参列表”表示指针变量指向的函数所带的参数列表。 例如: int (*f)(int x); double (*ptr)(double x); 在定义函数指针时请注意: 函数指针和它指向的函数的参数个数和类型都应该是—致的; 函数指针的类型和函数的返回值类型也必须是一致的。 2.函数指针的赋值 函数名和数组名一样代表了函数代码的首地址,因此在赋值时,直接将函数指针指向函数名就行了。 例如, int func(int x); /* 声明一个函数*/ int (*f) (int x); /* 声明一个函数指针*/ f=func; /* 将func函数的首地址赋给指针f */ 赋值时函数func不带括号,也不带参数,由于func代表函数的首地址,因此经过赋值以后,指针f就指向函数func(x)的代码的首地址。 3.通过函数指针调用函数 函数指针是通过函数名及有关参数进行调用的。
与其他指针变量相类似,如果指针变量pi是指向某整型变量i的指针,则*p等于它所指的变量i;如果pf是指向某浮点型变量f的指针,则*pf就等价于它所指的变量f。同样地,*f 是指向函数func(x)的指针,则*f就代表它所指向的函数func。所以在执行了f=func;之后,(*f)和func代表同一函数。 由于函数指针指向存储区中的某个函数,因此可以通过函数指针调用相应的函数。现在我们就讨论如何用函数指针调用函数,它应执行下面三步: 首先,要说明函数指针变量。 例如:int (*f)(int x); 其次,要对函数指针变量赋值。 例如:f=func; (func(x)必须先要有定义) 最后,要用(*指针变量)(参数表);调用函数。 例如:(*f)(x);(x必须先赋值) 【例】任意输入n个数,找出其中最大数,并且输出最大数值。 main() { int f(); int i,a,b; int (*p)(); /* 定义函数指针*/ scanf("%d",&a); p=f; /* 给函数指针p赋值,使它指向函数f */ for(i=1;i<9;i++) { scanf("%d",&b); a=(*p)(a,b); /* 通过指针p调用函数f */
详细理解C指针-指针函数与函数指针和回调函数
1、函数指针: 指针函数是指带指针的函数,即本质是一个函数。我们知道函数都又返回类型(如果不返回值,则为无值型),只不过指针函数返回类型是某一类型的指针。其定义格式如下所示: 返回类型标识符*返回名称(形式参数表) { 函数体} 返回类型可以是任何基本类型和复合类型。返回指针的函数的用途十分广泛。事实上,每一个函数,即使它不带有返回某种类型的指针,它本身都有一个入口地址,该地址相当于一个指针。比如函数返回一个整型值,实际上也相当于返回一个指针变量的值,不过这时的变量是函数本身而已,而整个函数相当于一个“变量”。例如下面一个返回指针函数的例子:float *find(float(*pionter)[4],int n)/*定义指针函数*/ { float *pt; pt=*(pionter+n); return(pt); } main() { static float score[][4]={{60,70,80,90},{56,89,34,45},{34,23,56,45}}; float *p; int i,m; printf("Enter the number to be found:"); scanf("%d",&m); printf("the score of NO.%d are:\n",m); p=find(score,m); for(i=0;i<4;i++) printf("%5.2f\t",*(p+i)); } 学生学号从0号算起,函数find()被定义为指针函数,起形参pointer是指针指向包含4个元素的一维数组的指针变量。pointer+1指向score的第一行。*(pointer+1)指向第一行的第0个元素。pt是一个指针变量,它指向浮点型变量。main()函数中调用find()函数,将score 数组的首地址传给pointer.
指针函数的定义
1.指针函数的定义 顾名思义,指针函数即返回指针的函数。其一般定义形式如下: 类型名*函数名(函数参数表列); 其中,后缀运算符括号“()”表示这是一个函数,其前缀运算符星号“*”表示此函数为指针型函数,其函数值为指针,即它带回来的值的类型为指针,当调用这个函数后,将得到一个“指向返回值为…的指针(地址),“类型名”表示函数返回的指针指向的类型”。 “(函数参数表列)”中的括号为函数调用运算符,在调用语句中,即使函数不带参数,其参数表的一对括号也不能省略。其示例如下: int *pfun(int, int); 由于“*”的优先级低于“()”的优先级,因而pfun首先和后面的“()”结合,也就意味着,pfun是一个函数。即: int *(pfun(int, int)); 接着再和前面的“*”结合,说明这个函数的返回值是一个指针。由于前面还有一个int,也就是说,pfun是一个返回值为整型指针的函数。 我们不妨来再看一看,指针函数与函数指针有什么区别? int (*pfun)(int, int); 通过括号强行将pfun首先与“*”结合,也就意味着,pfun是一个指针,接着与后面的“()”结合,说明该指针指向的是一个函数,然后再与前面的int 结合,也就是说,该函数的返回值是int。由此可见,pfun是一个指向返回值为int的函数的指针。 虽然它们只有一个括号的差别,但是表示的意义却截然不同。函数指针的本身是一个指针,指针指向的是一个函数。指针函数的本身是一个函数,其函数的返回值是一个指针。 2.用函数指针作为函数的返回值 在上面提到的指针函数里面,有这样一类函数,它们也返回指针型数据(地址),但是这个指针不是指向int、char之类的基本类型,而是指向函数。对于初学者,别说写出这样的函数声明,就是看到这样的写法也是一头雾水。比如,下面的语句: int (*ff(int))(int *, int);
指针函数和函数指针有什么区别
指针函数和函数指针有什么区别 1、指针函数,这两个概念都是简称,指针函数是指带指针的函数,即本质 是一个函数。我们知道函数都有返回类型(如果不返回值,则为无值型),只不 过指针函数返回类型是某一类型的指针。其定义格式如下所示: 返回类型标识符 *返回名称(形式参数表) { 函数体 } 返回类型可以是任何基本类型和复合类型。返回指针的函数的用途十分广 泛。事实上,每一个函数,即使它不带有返回某种类型的指针,它本身都有一 个入口地址,该地址相当于一个指针。比如函数返回一个整型值,实际上也相 当于返回一个指针变量的值,不过这时的变量是函数本身而已,而整个函数相 当于一个“变量” 。例如下面一个返回指针函数的例子: #i nclude float *find()? main() { static float score[][4] = {{60,70,80,90},{56,89,34,45},{34,23,56,45}}? float *p? int i,m? printf("Enter the number to be found:")? scanf("%d",&m)? printf("the score of NO.%d are:\n",m)? p = find(score,m)? for(i= 0?i<4?i++) printf("%5.2f\t",*(p+i))? } float *find(float (*pionter)[4], int n)/*定义指针函数*/ { float *pt? pt = *(pionter+n)? return(pt)? }
指针函数与函数指针
当一个函数声明其返回值为一个指针时,实际上就是返回一个地址给调用函数,以用于需要指针或地址的表达式中。 格式: 类型说明符* 函数名(参数) 当然了,由于返回的是一个地址,所以类型说明符一般都是int。 例如:int *GetDate(); int * aaa(int,int); 函数返回的是一个地址值,经常使用在返回数组的某一元素地址上。 int * GetDate(int wk,int dy); main() { int wk,dy; do { printf(Enter week(1-5)day(1-7)\n); scanf(%d%d,&wk,&dy); } while(wk<1||wk>5||dy<1||dy>7); printf(%d\n,*GetDate(wk,dy)); } int * GetDate(int wk,int dy) { static int calendar[5][7]= { {1,2,3,4,5,6,7}, {8,9,10,11,12,13,14}, {15,16,17,18,19,20,21}, {22,23,24,25,26,27,28}, {29,30,31,-1} }; return &calendar[wk-1][dy-1]; } 程序应该是很好理解的,子函数返回的是数组某元素的地址。输出的是这个地址里的值。 二、函数指针 指向函数的指针包含了函数的地址,可以通过它来调用函数。声明格式如下: 类型说明符(*函数名)(参数) 其实这里不能称为函数名,应该叫做指针的变量名。这个特殊的指针指向一个返回整型值的函数。指针的声明笔削和它指向函数的声明保持一致。 指针名和指针运算符外面的括号改变了默认的运算符优先级。如果没有圆括号,就变成了一个返回整型指针的函
函数指针的用法.doc
函数指针的用法 在程序运行中,函数代码是程序的算法指令部分,它们和数组一样也占用存储空间,都有相应的地址。可以使用指针变量指向数组的首地址来调用数组数据,也可以使用指针变量指向函数代码的首地址来调用函数,指向函数代码首地址的指针变量就称为函数指针。 1.函数指针定义 函数类型(*指针变量名)(形参列表); “函数类型”说明函数的返回类型,由于“()”的优先级高于“*”,所以指针变量名外的括号必不可少,后面的“形参列表”表示指针变量指向的函数所带的参数列表。 例如: int (*f)(int x); double (*ptr)(double x); 在定义函数指针时请注意: 函数指针和它指向的函数的参数个数和类型都应该是—致的; 函数指针的类型和函数的返回值类型也必须是一致的。 2.函数指针的赋值 函数名和数组名一样代表了函数代码的首地址,因此在赋值时,直接将函数指针指向函数名就行了。 例如, int func(int x); /* 声明一个函数*/ int (*f) (int x); /* 声明一个函数指针*/ 把函数的地址赋值给函数指针,可以采用下面两种形式: f=&func; /* 将func函数的首地址赋给指针f */ f=func; 赋值时函数func不带括号,也不带参数,由于func代表函数的首地址,因此经过赋值以后,指针f就指向函数func(x)的代码的首地址。
第二种格式看上去和函数调用无异。但是有些程序员倾向于使用第一种格式,因为它明确指出是通过指针而非函数名来调用函数的。 3、下面给出一个示例程序: #include void(*fp)();//函数指针: 指向函数的指针包含了函数的地址,可以通 过它来调用函数 void(*fp_para)(char*);//带参数的函数指针 void func_para(char*s); void func(); int main(void) { fp_para=&func_para;//或者:fp_para=func_para; (*fp_para)("This is the parameter of the funtion!"); fp=&func;//或者:fp=&func; (*fp)(); return 0; } void func_para(char*s) {