指向指针的指针——彻底搞定C指针

指向指针的指针——彻底搞定C指针
指向指针的指针——彻底搞定C指针

彻底搞定C指针---指向指针的指针

彻底搞定C指针---指向指针的指针一.回顾指针概念:

今天我们又要学习一个叫做指向另一指针地址的指针。让我们先回顾一下指针的概念吧!

当我们程序如下申明变量:

short int i;

char a;

short int * pi;

程序会在内存某地址空间上为各变量开辟空间,如下图所示。

内存地址→6 7 8 9 10 11 12 13 14 15

-------------------------------------------------------------------------------------

… | | | | | | | | | |

-------------------------------------------------------------------------------------

|short int i |char a| |short int * pi|

图中所示中可看出:

i 变量在内存地址5的位置,占两个字节。

a变量在内存地址7的位置,占一个字节。

pi变量在内存地址9的位置,占两个字节。(注:pi 是指针,我这里指针的宽度只有两个字节,32位系统是四个字节)

接下来如下赋值:

i=50;

pi=&i;

经过上在两句的赋值,变量的内存映象如下:

内存地址→6 7 8 9 10 11 12 13 14 15

--------------------------------------------------------------------------------------

… | 50 | | | 6 | | | |

--------------------------------------------------------------------------------------

|short int i |char a| |short int * pi|

看到没有:短整型指针变量pi的值为6,它就是I变量的内存起始地址。所以,这时当我们对*pi进行读写操作时,其实就是对i变量的读写操作。如:*pi=5; //就是等价于I=5;

你可以回看本系列的第二篇,那里有更加详细的解说。

二.指针的地址与指向另一指针地址的指针

在上一节中,我们看到,指针变量本身与其它变量一样也是在某个内存地址中的,如pi的内存起始地址是10。同样的,我们也可能让某个指针指向这个

地址。

看下面代码:

short int * * ppi; //这是一个指向指针的指针,注意有两个*号

ppi=π

第一句:short int * * ppi;——申明了一个指针变量ppi,这个ppi是用来存储(或称指向)一个short int * 类型指针变量的地址。

第二句:&pi那就是取pi的地址,ppi=π就是把pi的地址赋给了ppi。即将地址值10赋值给ppi。如下图:

内存地址→6 7 8 9 10 11 12 13 14 15

------------------------------------------------------------------------------------

… | 50 | | | 6 | 10 | |

------------------------------------------------------------------------------------

|short int i|char a| |short int * pi|short int ** ppi|

从图中看出,指针变量ppi的内容就是指针变量pi的起始地址。于是…… ppi的值是多少呢?——10。

*ppi的值是多少呢?——6,即pi的值。

**ppi的值是多少呢?——50,即I的值,也是*pi的值。

呵呵!不用我说太多了,我相信你应明白这种指针了吧!

三.一个应用实例

1.设计一个函数:void find1(char array[], char search, char * pi)

要求:这个函数参数中的数组array是以0值为结束的字符串,要求在字符串array中查找字符是参数search里的字符。如果找到,函数通过第三个参数(pa)返回值为array字符串中第一个找到的字符的地址。如果没找到,则为pa为0。

设计:依题意,实现代码如下。

void find1(char [] array, char search, char * pa)

{

int i;

for (i=0;*(array+i)!=0;i++)

{

if (*(array+i)==search)

{

pa=array+i

break;

}

else if (*(array+i)==0)

{

pa=0;

break;

}

}

}

你觉得这个函数能实现所要求的功能吗?

调试:

我下面调用这个函数试试。

void main()

{

char str[]={“afsdfsdfdf\0”}; //待查找的字符串

char a=’d’; //设置要查找的字符

char * p=0; //如果查找到后指针p将指向字符串中查找到的第一个字符的地址。

find1(str,a,p); //调用函数以实现所要操作。

if (0==p )

{

printf (“没找到!\n”);//1.如果没找到则输出此句

}

else

{

printf(“找到了,p=%d”,p); //如果找到则输出此句

}

}

分析:

上面代码,你认为会是输出什么呢?

运行试试。

唉!怎么输出的是:没有找到!

而不是:找到了,……。

明明a值为’d’,而str字符串的第四个字符是’d’,应该找得到呀!

再看函数定义处:void find1(char [] array, char search, char * pa)

看调用处:find1(str,a,p);

依我在第五篇的分析方法,函数调用时会对每一个参数进行一个隐含的赋值操作。

整个调用如下:

array=str;

search=a;

pa=p; //请注意:以上三句是调用时隐含的动作。

int i;

for (i=0;*(array+i)!=0;i++)

{

if (*(array+i)==search)

{

pa=array+i

break;

}

else if (*(array+i)==0)

{

pa=0;

break;

}

}

哦!参数pa与参数search的传递并没有什么不同,都是值传递嘛(小语:地址传递其实就是地址值传递嘛)!所以对形参变量pa值(当然值是一个地址值)的修改并不会改变实参变量p值,因此p的值并没有改变(即p的指向并没有被改变)。

(如果还有疑问,再看一看《第五篇:函数参数的传递》了。)

修正:

void find2(char [] array, char search, char ** ppa)

{

int i;

for (i=0;*(array+i)!=0;i++)

{

if (*(array+i)==search)

{

*ppa=array+i

break;

}

else if (*(array+i)==0)

{

*ppa=0;

break;

}

}

}

主函数的调用处改如下:

find2(str,a,&p); //调用函数以实现所要操作。

再分析:

这样调用函数时的整个操作变成如下:

array=str;

search=a;

ppa=&p; //请注意:以上三句是调用时隐含的动作。 int i;

for (i=0;*(array+i)!=0;i++)

{

if (*(array+i)==search)

{

*ppa=array+i

break;

}

else if (*(array+i)==0)

{

*ppa=0;

break;

}

}

看明白了吗?

ppa指向指针p的地址。

对*ppa的修改就是对p值的修改。

你自行去调试。

经过修改后的程序就可以完成所要的功能了。

函数指针

方法 指针函数和函数指针的区别 关于函数指针数组的定义 为函数指针数组赋值 函数指针的声明方法为: 数据类型标志符 (指针变量名) (形参列表); 注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是一个指针变量,不像函数名称那样是死的,它可以指向任何函数,就看你想怎么做了。在程序中把哪个

指向函数的指针详解

指向函数的指针 函数指针是指指向函数而非指向对象的指针。像其他指针一样,函数指针也指向某个特定的类型。函数类型由其返回类型以及形参表确定,而与函数名无关: 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.通过指针调用函数 指向函数的指针可用于调用它所指向的函数。可以不需要使用解引用

指针函数与函数指针的区别

指针函数与函数指针的区别 一、 在学习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++ 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)

函数指针的使用方法

对指针的应用是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指针-指针函数与函数指针和回调函数

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

相关文档
最新文档