指针函数的定义

指针函数的定义
指针函数的定义

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);

我们用上面介绍的方法分析一下,ff首先与后面的“()”结合,即:

int (*(ff(int)))(int *, int); // 用括号将

ff(int)再括起来

也就意味着,ff是一个函数。

接着与前面的“*”结合,说明ff函数的返回值是一个指针。然后再与后面的“()”结合,也就是说,该指针指向的是一个函数。

这种写法确实让人非常难懂,以至于一些初学者产生误解,认为写出别人看不懂的代码才能显示自己水平高。而事实上恰好相反,能否写出通俗易懂的代码是衡量程序员是否优秀的标准。一般来说,用typedef关键字会使该声明更简单易懂。在前面我们已经见过:

int (*PF)(int *, int);

也就是说,PF是一个函数指针“变量”。当使用typedef声明后,则PF就成为了一个函数指针“类型”,即:

typedef int (*PF)(int *, int);

这样就定义了返回值的类型。然后,再用PF作为返回值来声明函数:

PF ff(int);

下面将以程序清单1为例,说明用函数指针作为函数的返回值的用法。当程序接收用户输入时,如果用户输入d,则求数组的最大值,如果输入x,则求数组的最小值,如果输入p,则求数组的平均值。

程序清单1 求最值与平均值示例

1 #include

2 #include

3 double GetMin(double *dbData, int iSize) //求最小值

4 {

5 double dbMin;

6 int i;

7

8 assert(iSize>0);

9 dbMin=dbData[0];

10 for (i=1; i

11 if (dbMin>dbData[i]) {

12 dbMin=dbData[i];

13 }

14 }

15 return dbMin;

16 }

17

18 double GetMax(double *dbData, int iSize) //求最大值

19 {

20 double dbMax;

21 int i;

22

23 assert(iSize>0);

24 dbMax=dbData[0];

25 for (i=1; i

26 if (dbMax< dbData[i]) {

27 dbMax=dbData[i];

28 }

29 }

30 return dbMax;

31 }

32

33 double GetAverage(double *dbData, int iSize) //求平均值

34 {

35 double dbSum=0;

36 int i;

37

38 assert(iSize>0);

39 for (i=0; i

40 {

41 dbSum+=dbData[i];

42 }

43 return dbSum/iSize;

44 }

45

46 double UnKnown(double *dbData, int iSize) //未知算法

47 {

48 return 0;

49 }

50

51 typedef double (*PF)(double *dbData, int iSize); //定义函数指针类型

52 PF GetOperation(char c) //根据字符得到操作类型,返回函数指针

53 {

54 switch (c)

55 {

56 case 'd':

57 return GetMax;

58 case 'x':

59 return GetMin;

60 case 'p':

61 return GetAverage;

62 default:

63 return UnKnown;

64 }

65 }

66

67 int main(void)

68 {

69 double dbData[]={3.1415926, 1.4142, -0.5,999, -313, 365};

70 int iSize=sizeof(dbData)/sizeof(dbData[0]);

71 char c;

72

73 printf("Please input the Operation :\n");

74 c=getchar();

75 printf("result is %lf\n", GetOperation(c)(dbData,iSize)); //通过函数指针调用函数

76 }

上述程序中前面4个函数分别实现求最大值、最小值、平均值和未知算法,然后实现了GetOperation函数。这个函数根据字符的返回值实现上面4个函数。它是以函数指针的形式返回的,从后面的main函数的GetOperation(c)(dbData, iSize)可以看出,通过这个指针可以调用函数。

方法 指针函数和函数指针的区别 关于函数指针数组的定义 为函数指针数组赋值 函数指针的声明方法为: 数据类型标志符 (指针变量名) (形参列表); 注1:“函数类型”说明函数的返回类型,由于“()”的优先级高于“*”,所以指针变量名外的括号必不可少,后面的“形参列表”表示指针变量指向的函数所带的参数列表。例如: int func(int x); /* 声明一个函数 */ int (*f) (int x); /* 声明一个函数指针 */ f=func; /* 将func函数的首地址赋给指针f */ 赋值时函数func不带括号,也不带参数,由于func代表函数的首地址,因此经过赋值以后,指针f就指向函数func(x)的代码的首地址。 注2:函数括号中的形参可有可无,视情况而定。 下面的程序说明了函数指针调用函数的方法: 例一、 #include int max(int x,int y){ return(x>y?x:y); } void main() { int (*ptr)(int, int); int a,b,c; ptr=max; scanf("%d%d",&a,&b); c=(*ptr)(a,b); printf("a=%d,b=%d,max=%d",a,b,c); } ptr是指向函数的指针变量,所以可把函数max()赋给ptr作为ptr的值,即把max()的入口地址赋给ptr,以后就可以用ptr来调用该函数,实际上ptr 和max都指向同一个入口地址,不同就是ptr是一个指针变量,不像函数名称那样是死的,它可以指向任何函数,就看你想怎么做了。在程序中把哪个

C++指针函数习题 一、选择题 1.以下程序的运行结果是()。 sub(int x, int y, int *z) { *z=y-x; } void main() { int a,b; sub(10,5,&a); sub(7,a,&b); cout< #include<>

指向函数的指针 函数指针是指指向函数而非指向对象的指针。像其他指针一样,函数指针也指向某个特定的类型。函数类型由其返回类型以及形参表确定,而与函数名无关: bool (*pf)(const string &,const string &); 这个语句将pf声明为指向函数的指针,它所指向的函数带有两个const string &类型的形参和bool 类型的返回值。 注意:*pf两侧的括号是必需的。 1.typedef简化函数指针的定义: 函数指针类型相当地冗长。使用typedef为指针类型定义同义词,可将函数指针的使用大大简化: Typedef bool (*cmpfn)(const string &,const string &); 该定义表示cmpfn是一种指向函数的指针类型的名字。该指针类型为“指向返回bool类型并带有两个const string 引用形参的函数的指针”。在要使用这种函数指针类型时,只需直接使用cmpfcn即可,不必每次都把整个类型声明全部写出来。 2.指向函数的指针的初始化和赋值 在引用函数名但又没有调用该函数时,函数名将被自动解释为指向函数的指针。假设有函数: Bool lengthcompare(const string &,const string &); 除了用作函数调用的左操作数以外,对lengthcompare的任何使用都被解释为如下类型的指针:

bool (*)(const string &,const string &); 可使用函数名对函数指针初始化或赋值: cmpfn pf1=0; cmpfn pf2=lengthcompare; pf1=legnthcompare; pf2=pf1; 此时,直接引用函数名等效于在函数名上应用取地址操作符: cmpfcn pf1=lengthcompare; cmpfcn pf2=lengthcompare; 注意:函数指针只能通过同类型的函数或函数指针或0值常量表达式进行初始化或赋值。 将函数指针初始化为0,表示该指针不指向任何函数。 指向不两只函数类型的指针之间不存在转换: string::size_type sumLength(const string &,const string &); bool cstringCompare(char *,char *); //pointer to function returning bool taking two const string& cmpFcn pf;//error:return type differs pf=cstringCompare;//error:parameter types differ pf=lengthCompare;//ok:function and pointer types match exactly 3.通过指针调用函数 指向函数的指针可用于调用它所指向的函数。可以不需要使用解引用

int a; float b; a=3; b=5; 3AB0 a 3AB8 b 35

?变量与地址 程序中: int i; float k; 内存中每个字节有一个编号-----地址…... …... 2000200120022005 内存 2003 i k 编译或函数调用时为其分配内存单元 变量是对程序中数据存储空间的抽象

…... …... 2000 20042006 2005整型变量i 10 变量i _pointer 2001 20022003?指针:一个变量的地址 ?指针变量:专门存放变量地址的变量叫~ 2000 指针 指针变量 变量的内容 变量的地址 指针变量变量变量地址(指针) 变量值 指向 地址存入指针变量

指针变量与其所指向的变量之间的关系 ? 一般形式:[存储类型] 数据类型*指针名; 变量i*i_pointer 3 i 2000 i_pointer *i_pointer &i i_pointer i=3;*i_pointer=3 合法标识符指针变量本身的存储类型 指针的目标变量的数据类型 表示定义指针变量 不是‘*’运算符 例int*p1,*p2; float *q ; static char *name; 注意: 1、int *p1, *p2;与int *p1, p2; 2、指针变量名是p1,p2 ,不是*p1,*p2 3、指针变量只能指向定义时所规定类型的变量 4、指针变量定义后,变量值不确定,应用前必须先赋值 指针的定义

?指针是一种变量,在定义的同时可以赋给它初始值,称为指针的初始化。 ?形式如下: 类型标识符*指针名=初始地址值; 例如, int m,n[8];char c; int *pm = &m;int *pn = n;char *pc = &c; 变量地址作初值时, 该变量在此之前已说明过,且类型应一致。 可用已赋初值的指针 去初始化其他指针变量.

指针函数与函数指针的区别 一、 在学习arm过程中发现这“指针函数”与“函数指针”容易搞错,所以今天,我自己想一次把它搞清楚,找了一些资料,首先它们之间的定义: 1、指针函数是指带指针的函数,即本质是一个函数。函数返回类型是某一类型的指针 类型标识符 *函数名(参数表) int *f(x,y); 首先它是一个函数,只不过这个函数的返回值是一个地址值。函数返回值必须用同类型的指针变量来接受,也就是说,指针函数一定有函数返回值,而且,在主调函数中,函数返回值必须赋给同类型的指针变量。 表示: float *fun(); float *p; p = fun(a); 注意指针函数与函数指针表示方法的不同,千万不要混淆。最简单的辨别方式就是看函数名前面的指针*号有没有被括号()包含,如果被包含就是函数指针,反之则是指针函数。来讲详细一些吧!请看下面 指针函数: 当一个函数声明其返回值为一个指针时,实际上就是返回一个地址给调用函数,以用于需要指针或地址的表达式中。 格式: 类型说明符* 函数名(参数) 当然了,由于返回的是一个地址,所以类型说明符一般都是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));

如何透彻理解C语言中指针的概念 强大的指针功能是C语言区别于众多高级语言的一个重要特征。C语言指针的功能强大,使用灵活多变,可以有效地表示复杂的数据结构、动态分配内存、高效地使用数组和字符串、使得调用函数时得到多个返回值。而它的应用远不限于此。初学者对于指针的概念总是感到无所适从,有时觉得“自己懂了,为什么编译器就是不懂呢”,常有茫然和无助的感觉。 学好指针的关键在于深入了解内存地址的空间可以理解为一个一维线性空间,内存的编址和寻址方法,以及指针在使用上的一些规定。事实上,指针就是方便我们对内存地址直接进行操作的,是为程序员服务的,我们只要抓住指针想要帮助我们解决什么问题这个核心,就可以轻松地理解它的工作原理。 什么是指针,指针有什么作用 指针就是指向一个特定内存地址的一个变量。简化了的内存空间模型是按照从0到某一个数(比如1048575=1M-1)的一维线性空间,其中的每一个数对应一个存储单元,即1个字节。指针有两个属性:指向性和偏移性。指向性指的是指针一定要有一个确定的指向,偏移性则是体现指针重要应用的方面,即指针可以按程序员的要求向前或向后偏移。 指针的应用往往与数组联系在一起,为了方便说明问题,不妨从数组开始解释指针的偏移。数组就是许多的变量,它的一个重要特征就是在内存空间中连续地存放,而且是按下标顺序存放。比如我们定义一个有100个变量的一维整型数组,它一定从内存的某一个存储单元开始按数组下标顺序存放,连续占用100*4=400字节。当我们定义一个数组时,系统就会自动为它分配一个指针,这个指针指向数组的首地址。(在本文剩余部分的论述中,不加区分地使用“指向数组的首地址”与“指向数组的第一个元素”这两种说法,事实上这两种说法也是一致的。) 为了让系统了解每一次指针偏移的单位,也为了方便程序员进行指针偏移(让程序员记住一个整形变量占用4字节,一个字符型变量占用1字节……等等是很麻烦的),不用每次去计算要偏移多少个字节,C语言引入了指针的基类型的概念。基类型的作用就是让系统了解某个指针每次偏移的字节数。比如,对于一个字符型指针,它每次偏移(比如ptr=ptr+1)所起到的作用就是让指针偏移1字节;而对于一个整型指针,它每次偏移就应该是4字节。这样操作数组时就带来了方便。比如对于一个指向某个整型数组起始存储单元(称为首地址)的指针ptr,ptr=ptr+1就表示将该指针指向这个数组的下一个元素的存储单元,即向后移动4字节,而不仅仅是移动一个存储单元(即移动1字节)。 &()、*()、和[ ]运算符的意义 在本文中,将&()、*()和[ ]都看成是运算符。这样可以方便理解这三个概念。简单地说,&()将某个标识符(比如变量)转化为其在内存空间中的地址,而*()是产生一个对应于某个地址的标识符,[ ]就更复杂一点,ptr[i]表示

指向函数的指针 c/c++ 2010-11-20 13:17:02 阅读41 评论0 字号:大中小订阅首先看这个程序: #include using namespace std; void max(int a, int b) { cout<<"now call max("<b?a:b; cout<

我曾经写过一个命令行程序,有很多命令,于是构着了一个结构的数组,大概是这样 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)

函数练习题 【1.54】对函数形参的说明有错误的是____。 A) int a(float x[],int n) B) int a(float *x,int n) C) int a(float x[10],int n) D) int a(float x,int n) 【1.55】如果一个变量在整个程序运行期间都存在,但是仅在说明它的函数内是可见的,这个变量的存储类型应该被说明为____。 A)静态变量B) 动态变量C) 外部变量D) 内部变量 【1.56】在一个C源程序文件中,?若要定义一个只允许在该源文件中所有函数使用的变量,则该变量需要使用的存储类别是。 A) extern B) register C) auto D) static 【1.57】在C语言中,函数的数据类型是指____。 A)函数返回值的数据类型B) 函数形参的数据类型 C) 调用该函数时的实参的数据类型D) 任意指定的数据类型 【1.58】已知如下定义的函数: fun1(a) { printf("\n%d",a); } 则该函数的数据类型是____。 A)与参数a的类型相同B) void型 C) 没有返回值D) 无法确定 【1.59】定义一个函数实现交换x和y的值,并将结果正确返回。能够实现此功能的是____。 A) swapa(int x,int y) B) swapb(int *x,int *y) { int temp;{ int temp; temp=x;x=y;y=temp;temp=x;x=y;y=temp; } } C) swapc(int *x,int *y) D) swapd(int *x,int *y) { int temp;{ int *temp; temp=*x;*x=*y;*y=temp;temp=x;x=y;y=temp; } } 【1.60】求一个角的正弦函数值的平方。能够实现此功能的函数是____。 A) sqofsina(x) float x; { return(sin(x)*sin(x)); } B) double sqofsinb(x) float x; { return(sin((double)x)*sin((double)x)); } C) double sqofsinc(x) { return(((sin(x)*sin(x)); } D) sqofsind(x) float x;

每个指针都有一个与之关联的数据类型,该数据类型决定了指针所有指向的对象的类型。例如,一个int 型指针只能指向int 型对象。 1.指针变量的定义 C++语言使用* 号把一个标识符声明为指针: vector *pvec; int *p1, *p2; string *pstring; 提示:理解指针声明语句时,请从右向左阅读。 2.另一种声明指针的风格 在定义指针变量时,可用空格符号* 与气候的标识符分别开来,如下: string* ps; 也就是说,该语句把ps定义为一个指向string 类型对象的指针。 这种指针声明风格容易引起这样的误解:把string * 理解为一种数据类型,认为在同意声明语句中定义的其他变量也指向string 类型对象的指针。 如果使用下面的语句: string* p1, p2;

实际上只把ps1 定义为指针,而ps2并非指针,只是一个普通的string 对象而已。如果需要在一个声明语句中定义了两个指针,必须在每一个变量标识符前再加符号* 声明: string* ps1,*ps2; 3.指针的可能取值 一个有效的指针必然是以下三种状态之一:1.保存一个特定对象的地址;2.指向某个对象后面的另一对象;3.是0值。若指针保存0值,表明它不指向任何对象。未初始化的指针是无效的,直到给该指针赋值后,才可以使用它。下面的定义是合法的: int ival = 1024; int *pi = 0; int *pi2 = &ival; int *pi3; pi = pi2; pi2 = 0; 4.避免使用未初始化的指针 提示:很多运行时错误都源于使用了未初始化的指针。 就像使用其他没有初始化的变量一样,使用未初始化的指针时的行为C++标准中并没有定义,它几乎总会导致运行时崩溃。然而,导致崩溃的这一原因很难发现。

对指针的应用是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; }

陕西理工大学 《高级语言程序设计(C)》 实验报告 院系: 班级: 学号: 姓名:

目录 实验一:C开发环境与顺序结构程序设计 (2) 1.实验目的: (2) 2.实验环境: (2) 3.实验步骤: (2) 4.实验内容: (2) 5.实验总结 (9) 实验二:分支结构与循环结构程序设计 (10) 1.实验目的: (10) 2.实验环境: (10) 3.实验内容: (10) 4.实验总结 (18) 实验三数组及数组的应用 (19) 1.实验目的: (19) 2.实验环境: (19) 3.实验内容: (19) 4.实验总结: (20) 实验四:函数与指针 (20) 1.实验目的: (21) 2.实验内容: (21) 3.实验总结 (24)

实验一:C开发环境与顺序结构程序设计 1.实验目的: (1) 了解集成开发环境VC++6.0的使用方法,理解相关命令的含义,掌握编辑、编译、连接以及运行调试的方法,掌握程序的基本结构,掌握输入输出的方式。 (2) 掌握程序设计的基本要素中的数据类型、变量、运算符以及表达式的运用。 (3) 学会正确使用逻辑运算符和逻辑表达式以及关系运算符与关系表达式,掌握在程序设计中灵活使用顺序结构。 2.实验环境: (1) 硬件环境 CPU:Inter Pentium(R)4 CPU 3.00GHz 以上 内存:2GByte (2) 软件环境 操作系统:Microsoft Windows 7 编译系统:Microsoft Visual C++ 6.0 3.实验步骤: 按如图所示流程进行实验内容的 调试。 (1) 在XP操作系统中,启动 VC++6.0编译环境; (2) 在VC++6.0编译界面输入C源 程序; (3) 选择编译、组建、执行命令进 行编译、链接和运行,并记录实验 数据; (4) 按以上方法依次输入其他源程 序并调试、运行和记录实验数据。 4.实验内容: 4.1 输入并运行下列程序,查看程序运行的结果。 #include

C# 如何跨平台调用C++的函数指针! 函数指针搞C++的人应该都知道,效率高,易用性强,隐蔽代码等。在C++里面调用C++写的dll的函数指针那是在容易不过了。使用C#就稍微麻烦点了!那怎么掉呢?通过上面的第一篇文章我们知道应该使用委托 delegate。如果再高级点,定义一个函数指针结构(有点像linux的内核),也同样可以用C#调用。 提示:委托就和C++中的函数指针一样 借用一下别人的列子:在C++的一个标准Win32 api 库ccLic.dll中有一个函数void* WINAPI GetFunctionAddress(unsigned int sn);此函数通过传sn序号得到函数指针即一个函数的地址.之后再通过返回回来的地址进行其它函数的调用那么我们必须知道.一个sn号对应的函数结构如 sn=1 -> bool WINAPI CCAskServerLicenseInfo(const char* server_address,unsigned short port,PCcLic_Info plicenseinfo) 在其中 typedef struct _CcLic_Info { char ower[64]; unsigned short manage_ip; unsigned short ramained_ip; unsigned short useable_time; unsigned char type; } CcLic_Info,*PCcLic_Info; 此列的目的就是通过C#调用 CCAskServerLicenseInfo 函数. [DllImport(@"ccLic.dll")] public static extern System.IntPtr Matrix(System.UInt32 sn);//声名入口函数 //定义函数指针模型 public delegate System.Int32 CCAskServerLicenseInfoHandle(Syste m.String servername, System.UInt16 port, System.IntPtr ptr); public static LicenseInfo GetLicentInfo(String server, System.UInt16

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);当然从上述例子看不出函数指针的优点,目的主要是想引出函数指针数组的概念。我们从上面例子可以得知,既然函数名可以通过函数指针加以保存,那们也一定能定义一个数组保存若干个函数名,这就是函数指针数组。正确使用函数指针数组的前提条件是,这若干个需要通过函数指针数组保存的函

我知道函数指针是指向函数的指针,指针函数还是指一个函数的返回值是一个指针,但下面的几道题还是感觉很迷惑。各位能否讲的详细点呢? (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的类型的函数。 至此解析完毕。

复杂的函数指针例子分析2008-01-26 11:38:22 分类: 一个最简单的函数指针定义如下: Void (*funcPtr) (); //funcptr是一个函数指针,它指向的函数没有参数,返回值为void 非常复杂的函数指针定义: 1.Void*(*(*fpl)(int))[10]; 解析:Void * 这是一个有10个void*类型的元素的数组。 x=* ( * fpl)(int),从而可以看出(*fpl) (int)它是一个指 针,指向一个数组。这个数组有10个void指针类型的元素。 Fpl是一个函数指针,它的参数是一个int型的参数。返回值为一个指向含有1。个void*元素的数组的指针。 2.Void*( *fpl)(int)[10]; 解析:void*X[10];今X是一个有着[。个void*类型的数组 x=( * fpl)(int); Fpl是一个函数指针,它有一个整型参数,其返回值是一个有着1()个void* 类型的元素的数组。 若是这个形式Ve i d-*-—和?块40], 则状返物=-令指向含有个v&d 类型的数组的指针U 3.Void(*fpl)(int)[10]; 解析:void X[10]->X是一个有着1()个void类型的数组 x=( * fpl)(int); Fpl是一个函数指针,它有一个整型参数,其返回值是一个有着10个void 类型的元素的数组 若是这个形式,Void ( * fpl)(int)[10],则其返回值为一个有1()个void类型的数组。 4?Float (*(*fp2)(int,int,float))(int); 解析:Float X(int)今X是一个函数,有,个整型参数,返回值是一个浮点数。

1函数类型(* 函数指针变量)();//指向函数的入口地址 一个函数是若干语句的集合,经编译后存储在函数代码存储区,并占有一片连续的存储空间,对函数指针只能用函数名赋值而无其他运算 1#include 2 3int max(int x ,int y); 4 5int main() 6{ 7int(* p)() ;//定义p是指向函数的指针变量 8int a , b , c ; 9 10p= max ;//将函数max的入口地址赋给指针变量p 11scanf("%d %d",&a ,&b) ; 12c= (* p)(a , b) ;//用指向函数的指针变量p调用函数 13printf("a = %d , b = %d , max = %d", a , b , c); 14 15return0; 16} 17 18int max(int x ,int y) 19{ 20int k ; 21k= (x> y)? x : y ; 22 23return k ; 24} 函数名作为实际参数: 1 #include 2 3int fun1(int a , int b) 4 { 5return a+b ; 6 } 7 8int fun2(int (*q)() , int x , int y) 9 { 10return (*q)(x , y) ; 11 } 12 13int main() 14 { 15int (*p)() , k ; 16 p = fun1 ;

17 k = fun2( p , 8 , 5 ) ; 18 19printf("k = %d \n" , k); //输出 13 20 21return0 ; 22 } 设置一个函数proc ,每次调用它会实现不同的功能,输入 a , b 两个数,第一次调用proc时,找出两者中最大者,第二次找出最小者,第三次调用求两数之差: 1 #include 2 3int max(int *x , int *y); 4int min(int *x , int *y); 5int a_b(int *x , int *y); 6int proc(int *x , int *y , int(*p)()); 7 8int main() 9 { 10int a , b ; 11 12printf("Enter a and b :"); 13scanf("%d %d" , &a , &b); 14 15printf("a = %d \t b = %d \n" , a , b); 16 17printf("max(%d,%d) = " , a , b); 18 proc(&a , &b , max); 19 20printf("min(%d,%d) = " , a , b); 21 proc(&a , &b , min); 22 23printf("%d - %d = " , a , b); 24 proc(&a , &b , a_b); 25 26return0 ; 27 } 28 29int max(int *x , int *y) 30 { 31int k ; 32 33 k = (*x > *y) ? *x : *y ; 34 35return k ; 36 } 37 38int min(int *x , int *y)

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”中填入()中的内容。

(void (*)())0 的含义 (void (*)())0 的含义: 1. fp是一个指针{有*},她指向返回值为void{有(void)}类型的函数{有()}:void (*fp)(); 调用方式简写为:(*fp)(); 2. 制作其对应的类型强制转换符:void (*)() 3. 存储位置为0 的强制转换为一个指向返回值为void类型的函数的指针:(void (*)())0 4. 用上式代替fp,从而实现调用存储位置为0的子例程:(*(void(*)())0)(); 5. 利用typedef简化:typedef void (*funcptr)(); (*(funcptr)0)(); (void (*)())0 的含义:实际上就是将地址0强制转换为一个指向返回值为void类型的函数的指针。 下面将相关基础知识进行介绍,其中参考了网上一些文章,名单不再列出,谢谢各位大虾的贡献: 1、c语言的声明 2、类型转换符的制作 3、signal函数分析 4、typedef用法 5、const用法 6、typedef的好处 1 C语言的声明 声明由两部分组成:类型以及声明符: float f,g; float ((f));//对其求值时,((f))的类型为浮点型,可以推知,f也是浮点型 float *g(),(*h)();//g是函数,该函数的返回类型为指向浮点数的指针 //h是个指针,且是一个函数指针,该指针指向函数返回值,该返回值是一个float型 (*fp)()简写为fp()//函数调用方式,其中fp为函数指针 *((*fp)())简写为*fp()//函数返回值为某个类型的指针 、2 类型转换符制作 类型转换符制作: 1、去掉声明中的变量名、分号; 2、将剩余部分用括号"封装"起来 float (*h)(); --> (float (*)())//指向返回值为float型的函数指针的类型转换符(*0)();//返回值为void类型的函数指针 如果fp是一个指向返回值为void类型的函数的指针,那么(*fp)()的值为 void,fp的声明如下:void (*fp)(); 因此可以用下式完成调用存储位置为0的子例程:void (*fp)(); (*fp)(); 这种写法的代价是多声明了一个哑变量,我们常将0转型为“指向返回值为void的函数的指针”:(void (*)())0 用上式代替fp,从而得到:(*(void(*)())0)(); typedef void (*funcptr)(); 将0转型为“指向返回值为void的函数的指针”-----(void (*)())0 (*(funcptr)0)(); 3 signal函数

相关文档
最新文档