指针变量作为函数参数

指针变量作为函数参数
指针变量作为函数参数

用名作为其他变量名地别名.

; 等价于;

()声明一个引用,不是新定义了一个变量,它只表示该引用名是目标变量名地一个别名,它本身不是一种数据类型,因此引用本身不占存储单元,系统也不给引用分配存储单元.故:对引用求地址,就是对目标变量求地址.与相等.

()不能建立数组地引用.因为数组是一个由若干个元素所组成地集合,所以无法建立一个数组地别名.

引用应用

、引用作为参数

引用地一个重要作用就是作为函数地参数.以前地语言中函数参数传递是值传递,如果有大块数据作为参数传递地时候,采用地方案往往是指针,因为这样可以避免将整块数据全部压栈,可以提高程序地效率.但是现在(中)又增加了一种同样有效率地选择(在某些特殊情况下又是必须地选择),就是引用.

【例】:

( , ) 此处函数地形参, 都是引用

{ ; ; ; ; }

为在程序中调用该函数,则相应地主调函数地调用点处,直接以变量作为实参进行调用即可,而不需要实参变量有任何地特殊要求.如:对应上面定义地函数,相应地主调函数可写为:

( )

{

;

>>>>; 输入两变量地值

(); 直接以变量和作为实参调用函数

<<<< ' ' <<; 输出结果

}

上述程序运行时,如果输入数据并回车后,则输出结果为.

由【例】可看出:

()传递引用给函数与传递指针地效果是一样地.这时,被调函数地形参就成为原来主调函数中地实参变量或对象地一个别名来使用,所以在被调函数中对形参变量地操作就是对其相应地目标对象(在主调函数中)地操作.

()使用引用传递函数地参数,在内存中并没有产生实参地副本,它是直接对实参操作;而使用一般变量传递函数地参数,当发生函数调用时,需要给形参分配存储单元,形参变量是实参变量地副本;如果传递地是对象,还将调用拷贝构造函数.因此,当参数传递地数据较大时,用引用比用一般变量传递参数地效率和所占空间都好.

()使用指针作为函数地参数虽然也能达到与使用引用地效果,但是,在被调函数中同样要给形参分配存储单元,且需要重复使用"*指针变量名"地形式进行运算,这很容易产生错误且程序地阅读性较差;另一方面,在主调函数地调用点处,必须用变量地地址作为实参.而引用更容易使用,更清晰.

如果既要利用引用提高程序地效率,又要保护传递给函数地数据不在函数中被改变,就应使用常引用.

、常引用

常引用声明方式:类型标识符引用名目标变量名;

用这种方式声明地引用,不能通过引用对目标变量地值进行修改,从而使引用地目标成为,达到了引用地安全性.

【例】:

;

;

; 错误

; 正确

这不光是让代码更健壮,也有些其它方面地需要.

【例】:假设有如下函数声明:

( );

( );

那么下面地表达式将是非法地:

(( ));

(" ");

原因在于( )和" "串都会产生一个临时对象,而在中,这些临时对象都是类型地.因此上面地表达式就是试图将一个类型地对象转换为非类型,这是非法地.

引用型参数应该在能被定义为地情况下,尽量定义为.

、引用作为返回值

要以引用返回函数值,则函数定义时要按以下格式:

类型标识符函数名(形参列表及类型说明)

{函数体}

说明:

()以引用返回函数值,定义函数时需要在函数名前加

()用引用

返回一个函数值地最大好处是,在内存中不产生被返回值地副本.

【例】以下程序中定义了一个普通地函数(它用返回值地方法返回函数值),另外一个函数,它以引用地方法返回函数值.

<>

; 定义全局变量

( ); 声明函数

( ); 声明函数

( ) 定义函数,它以返回值地方法返回函数值

{

()(**);

;

}

( ) 定义函数,它以引用方式返回函数值

{

()(**);

;

}

() 主函数

{

(); 第种情况,系统生成要返回值地副本(即临时变量)(); 第种情况,可能会出错(不同系统有不同规定)不能从被调函数中返回一个临时变量或局部变量地引用(); 第种情况,系统不生成返回值地副本

可以从被调函数中返回一个全局变量地引用

(); 第种情况,系统不生成返回值地副本

可以从被调函数中返回一个全局变量地引用

<<<<<<;

}

引用作为返回值,必须遵守以下规则:

()不能返回局部变量地引用.这条可以参照[]地.主要原因是局部变量会在函数返回后被销毁,因此被返回地引用就成为了"无所指"地引用,程序会进入未知状态.

()不能返回函数内部分配地内存地引用.这条可以参照[]地.虽然不存在局部变量地被动销毁问题,可对于这种情况(返回函数内部分配内存地引用),又面临其它尴尬局面.例如,被函数返回地引用只是作为一个临时变量出现,而没有被赋予一个实际地变量,那么这个引用所指向地空间(由分配)就无法释放,造成.

()可以返回类成员地引用,但最好是.这条原则可以参照[]地.主要原因是当对象地属性是与某种业务规则()相关联地时候,其赋值常常与某些其它属性或者对象地状态有关,因此有必要将赋值操作封装在一个业务规则当中.如果其它对象可以获得该属性地非常量引用(或指针),那么对该属性地单纯赋值就会破坏业务规则地完整性.

()引用与一些操作符地重载:

流操作符<<和>>,这两个操作符常常希望被连续使用,例如:<< "" << ;因此这两个操作符地返回值应该是一个仍然支持这两个操作符地流引用.可选地其它方案包括:返回一个流对象和返回一个流对象指针.但是对于返回一个流对象,程序必须重新(拷贝)构造一个新地流对象,也就是说,连续地两个<<操作符实际上是针对不同对象地!这无法让人接受.对于返回一个流指针则不能连续使用<<操作符.因此,返回一个流对象引用是惟一选择.这个唯一选择很关键,它说明了引用地重要性以及无可替代性,也许这就是语言中引入引用这个概念地原因吧. 赋值操作符.这个操作符象流操作符一样,是可以连续使用地,例如:;或者();赋值操作符地返回值必须是一个左值,以便可以被继续赋值.因此引用成了这个操作符地惟一返回值选择.

【例】测试用返回引用地函数值作为赋值表达式地左值.

<>

( );

[];

;

()

{

(); 以()函数值作为左值,等价于[];

(); 以()函数值作为左值,等价于[];

<<[];

<<[];

}

( )

{

(> < ) [];

{ <<" "; ; }

}

()在另外地一些操作符中,却千万不能返回引用:* 四则运算符.它们不能返回引用,[]地详细地讨论了这个问题.主要原因是这四个操作符没有,因此,它们必须构造一个对象作为返回值,可选地方案包括:返回一个对象、返回一个局部变量地引用,返回一个分配地对象地引用、返回一个静态对象引用.根据前面提到地引用作为返回值地三个规则,第、两个方案都被否决了.静态对象地引用又因为(() ())会永远为而导致错误.所以可选地只剩下返回一个对象了.

、引用和多态

引用是除指针外另一个可以产生多态效果地手段.这意味着,一个基类地引用可以指向它地派生类实例.

【例】:

;

:{……};

;

; 用派生类对象初始化基类对象地引用

C指针函数习题

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

指向指针的指针——彻底搞定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。同样的,我们也可能让某个指针指向这个

函数指针

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

指针变量作为函数参数

用名作为其他变量名地别名. ; 等价于; ()声明一个引用,不是新定义了一个变量,它只表示该引用名是目标变量名地一个别名,它本身不是一种数据类型,因此引用本身不占存储单元,系统也不给引用分配存储单元.故:对引用求地址,就是对目标变量求地址.与相等. ()不能建立数组地引用.因为数组是一个由若干个元素所组成地集合,所以无法建立一个数组地别名. 引用应用 、引用作为参数 引用地一个重要作用就是作为函数地参数.以前地语言中函数参数传递是值传递,如果有大块数据作为参数传递地时候,采用地方案往往是指针,因为这样可以避免将整块数据全部压栈,可以提高程序地效率.但是现在(中)又增加了一种同样有效率地选择(在某些特殊情况下又是必须地选择),就是引用. 【例】: ( , ) 此处函数地形参, 都是引用 { ; ; ; ; } 为在程序中调用该函数,则相应地主调函数地调用点处,直接以变量作为实参进行调用即可,而不需要实参变量有任何地特殊要求.如:对应上面定义地函数,相应地主调函数可写为: ( ) { ; >>>>; 输入两变量地值 (); 直接以变量和作为实参调用函数 <<<< ' ' <<; 输出结果 }

上述程序运行时,如果输入数据并回车后,则输出结果为. 由【例】可看出: ()传递引用给函数与传递指针地效果是一样地.这时,被调函数地形参就成为原来主调函数中地实参变量或对象地一个别名来使用,所以在被调函数中对形参变量地操作就是对其相应地目标对象(在主调函数中)地操作. ()使用引用传递函数地参数,在内存中并没有产生实参地副本,它是直接对实参操作;而使用一般变量传递函数地参数,当发生函数调用时,需要给形参分配存储单元,形参变量是实参变量地副本;如果传递地是对象,还将调用拷贝构造函数.因此,当参数传递地数据较大时,用引用比用一般变量传递参数地效率和所占空间都好. ()使用指针作为函数地参数虽然也能达到与使用引用地效果,但是,在被调函数中同样要给形参分配存储单元,且需要重复使用"*指针变量名"地形式进行运算,这很容易产生错误且程序地阅读性较差;另一方面,在主调函数地调用点处,必须用变量地地址作为实参.而引用更容易使用,更清晰. 如果既要利用引用提高程序地效率,又要保护传递给函数地数据不在函数中被改变,就应使用常引用. 、常引用 常引用声明方式:类型标识符引用名目标变量名; 用这种方式声明地引用,不能通过引用对目标变量地值进行修改,从而使引用地目标成为,达到了引用地安全性. 【例】: ; ; ; 错误 ; 正确 这不光是让代码更健壮,也有些其它方面地需要. 【例】:假设有如下函数声明:

指针练习题

. 编程题 1用指向数组的指针变量输出数组的全部元素 2 使用函数调用,形参为指针,实参为数组,把一个数组逆序存放在输出 练习题: 一判断题 1.指针是变量,它具有的值是某个变量或对象的地址值,它还具有一个地址值,这两个地址值是相等的。 2.指针的类型是它所指向的变量或对象的类型。 3.定义指针时不可以赋初值。 4.指针可以赋值,给指针赋值时一定要类型相同,级别一致。5.指针可以加上或减去一个int型数,也可以加上一个指针。6.两个指针在任何情况下相减都是有意义的。 7.数组元素可以用下标表示,也可以用指针表示。 8.指向数组元素的指针只可指向数组的首元素。 9.字符指针是指向字符串的指针,可以用字符串常量给字符指针赋值。 10.引用是一种变量,它也有值和地址值。 11.引用是某个变量的别名,引用是被绑定在被引用的变量上。

12.创建引用时要用一个同类型的变量进行初始化。 13.指针是变量,它可以有引用,而引用不能有引用。 ;. . 二单选题 1.下列关于定义一个指向double型变量的指针,正确的是()。A.int a(5);double *pd=a; B.double d(2.5),*pd=&d;C.double d(2.5),*pd=d; D.double a(2.5),pd=d;。).下列关于创建一个int型变量的引用,正确的是(2A.int a(3),&ra=a; B int . a(3),&ra=&a;ra=a;D.int a(3), C.double d(3.1);int &rd=d;.下列关于指针概念的描述中,错误的是()。3 A.指针中存放的 是某变量或对象的地址值.指针的类型是它所存放的数值的类型 B .指针是变量,它也具有一个内存地址值 C .指针的值是可以改 变的D 。.下列关于引用概念的描述中,错误的是()4 A.引 用是变量,它具有值和地址值 B.引用不可以作数组元素 C.引用是变量的别名 D.创建引用时必须进行初始化。++*p相同的是()*p=a5.已知:int a[5],;则与a[0] . B.*++p A++a[0] .C*p++ D.;. . 6.已知:int a[ ]={1,2,3,4,5},*p=a;在下列数组元素地址的表

指针练习题

编程题 1用指向数组的指针变量输出数组的全部元素 2 使用函数调用,形参为指针,实参为数组,把一个数组逆序存放在输出 练习题: 一判断题 1.指针是变量,它具有的值是某个变量或对象的地址值,它还具有一个地址值,这两个地址值是相等的。 2.指针的类型是它所指向的变量或对象的类型。 3.定义指针时不可以赋初值。 4.指针可以赋值,给指针赋值时一定要类型相同,级别一致。 5.指针可以加上或减去一个int型数,也可以加上一个指针。 6.两个指针在任何情况下相减都是有意义的。 7.数组元素可以用下标表示,也可以用指针表示。 8.指向数组元素的指针只可指向数组的首元素。 9.字符指针是指向字符串的指针,可以用字符串常量给字符指针赋值。 10.引用是一种变量,它也有值和地址值。 11.引用是某个变量的别名,引用是被绑定在被引用的变量上。 12.创建引用时要用一个同类型的变量进行初始化。 13.指针是变量,它可以有引用,而引用不能有引用。

二单选题 1.下列关于定义一个指向double型变量的指针,正确的是()。 A.int a(5);double *pd=a;B.double d(2.5),*pd=&d;C.double d(2.5),*pd=d;D.double a(2.5),pd=d; 2.下列关于创建一个int型变量的引用,正确的是()。 A.int a(3),&ra=a;B.int a(3),&ra=&a; C.double d(3.1);int &rd=d;D.int a(3),ra=a; 3.下列关于指针概念的描述中,错误的是()。 A.指针中存放的是某变量或对象的地址值 B.指针的类型是它所存放的数值的类型 C.指针是变量,它也具有一个内存地址值 D.指针的值是可以改变的 4.下列关于引用概念的描述中,错误的是()。 A.引用是变量,它具有值和地址值 B.引用不可以作数组元素 C.引用是变量的别名 D.创建引用时必须进行初始化 5.已知:int a[5],*p=a;则与++*p相同的是()。 A.*++p B.a[0] C.*p++ D.++a[0]

指向函数的指针详解

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

指向函数的指针

指向函数的指针 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)

如何用指向函数的指针替换switch-case

程序中当switch-case里面有很多分支,且每个分支有很多操作要做时,会花费很多时间,优化的方法有很多,比如将可能性大的放在前面,将case操作压缩,其实,最好的方法利用指向函数的指针解决问题,下面我们来看一个例子: 先来一个switch-case的模板: view plaincopy to clipboardprint? 1. #include 2. #include 3. 4. enum MsgType{ Msg1=1 ,Msg2 ,Msg3 ,Msg4 }; 5. 6. int menu() 7. { 8. int choice; 9. printf("1.ADD/n"); 10. printf("2.DEL/n"); 11. printf("3.SORT/n"); 12. printf("4.exit/n"); 13. printf("input your choice:/n"); 14. scanf("%d",&choice); 15. return choice; 16. } 17. 18. void ADD() 19. { 20. NULL; 21. // 22. } 23. 24. void DEL() 25. { 26. NULL; 27. // 28. } 29. 30. void SORT() 31. { 32. NULL; 33. // 34. } 35. 36. int main()

37. { 38. while(1) 39. { 40. switch(menu()) 41. { 42. case Msg1: 43. ADD(); 44. break; 45. case Msg2: 46. DEL(); 47. break; 48. case Msg3: 49. SORT(); 50. break; 51. case Msg4: 52. exit(0); 53. break; 54. default: 55. printf("input error/n"); 56. break; 57. } 58. } 59. return 0; 60. } 61. 62. 1. #include 2. #include 3. 4. void ADD(); 5. void DEL(); 6. void SORT();

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

指针函数与函数指针的区别 一、 在学习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语言——指向函数的指针

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)

指向对象的指针变量

指向对象的指针变量 定义的一般形式: 类名*指针变量名; p-> (*p). 指向对象的成员变量的指针变量: 1.该指针变量可出现在成员函数中,通过获取该成员变量的地址,然后通过(*指针变量名)访问该成员变量 class aa { int a; public: aa() { a=0; } aa(int a) { this->a=a; } void get_a() { int *p; p=&a; cout<<*p<a=a; } void get_a() { int *p; p=&a; cout<<*p<

} }; int main() { aa b(3); b.get_a(); aa *p; p=new aa[2]; (p+1)->get_a(); p[1].get_a(); int *q; q=&b.a; return 0; } 指向成员函数的指针变量: 定义的一般形式: 函数类型名(类名::*指针变量名)(参数); 赋值的一般形式: 指针变量名=对象名.成员函数名 指针变量名=&类名.成员函数名或指针变量名=类名.成员函数名通过指针变量引用对象的成员函数 一般形式:(对象名.*指针变量名)(参数) this指针 #include using namespace std; class aa { int a; public: aa() { a=0; } aa(int a) { this->a=a; } void get_a() { cout<a<

函数指针的使用方法

对指针的应用是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指针函数习题 文件编码(008-TTIG-UTITD-GKBTT-PUUTI-WYTUI-8256)

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

C)p=&a;scanf(“%lf”,*p);D)p=&a;scanf(“%lf”,p); 6.若有语句int*point,a=4;和point=&a;下面均代表地址的一组选项是()。 A)a,point,*&aB)&*a,&a,*pointC)*&point,*point,&aD)&a,&*point,point 7.设char*s="\ta\103bc";则指针变量s指向的字符串所占的字节数是()。 A)9B)5C)6D)7 8.下面程序段的运行结果是()。 char*s="abcde";s+=2;cout< #include<> intmain() { char*s1="AbDeG"; char*s2="Abdeg"; s1+=2;s2+=2;

指向函数的指针变量

1.一般定义形式: 返回值的数据类型(*指针变量名)(); for example: int function(int a, int b){...;} int (*pointer_of_function)(); pointer_of_function = function; //相关联的语句就是这么简单。 2.函数的调用可以通过函数名调用,也可以通过函数指针调用(即用指向函数的指针变量调用)。 3.(*p)() 表示定义一个指向函数的指针变量,它不是固定指向哪一个函数的,而只是表示定义了这样一个类型的变量,它是专门用来存放函数的入口地址的。在程序中把哪一个函数的地址赋给它,它就指向哪一个函数。在一个程序中,一个指针变量可以先后指向返回类型相同的不同的函数。 4.在给函数指针变量赋值时,只需给出函数名而不必给出参数,如:pointer_of_function = function ,因为是将函数入口地址赋给pointer_of_function, 而不牵涉到实参与形参结合的问题。不能写成pointer_of_function = function(a,b)。 5.用函数指针变量调用函数时,只需将(*P)代替函数名即可,在(*p)之后的括弧中根据需要写上实参。 6.对指向函数的指针变量,像p++ 等类似运算是没有意义的。 7.区别int (*p)() 与int *p():由于()的优先级高于*,它就成了声明一个函数了,这个函数的返回值是指向整形变量的指针。 1 定义和调用 程序在编译后,每个函数都有一个首地址(也就是函数第一条指令的地址),这个地址称为函数的指针。可以定义指向函数的指针变量,使用指针变量间接调用函数。下面通过一个简单的例子来说明: float max(float x,float y) { return x>y?x:y; } float min(float x,float y) { return x

函数指针和指针函数

在程序运行中,函数代码是程序的算法指令部分,它们和数组一样也占用存储空间,都有相应的地址。可以使用指针变量指向数组的首地址,也可以使用指针变量指向函数代码的首地址,指向函数代码首地址的指针变量称为函数指针。 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);

指针总结

让你不再害怕指针 前言:复杂类型说明 要了解指针,多多少少会出现一些比较复杂的类型,所以我先介绍 一下如何完全理解一个复杂类型,要理解复杂类型其实很简单,一 个类型里会出现很多运算符,他们也像普通的表达式一样,有优先 级,其优先级和运算优先级一样,所以我总结了一下其原则: 从变量名处起,根据运算符优先级结合,一步一步分析. 下面让我们先从简单的类型开始慢慢分析吧: int p; //这是一个普通的整型变量 int *p; //首先从P处开始,先与*结合,所以说明P是一 //个指针,然后再与int结合,说明指针所指向 //的内容的类型为int型.所以P是一个返回整 //型数据的指针 int p[3]; //首先从P处开始,先与[]结合,说明P是一个数 //组,然后与int结合,说明数组里的元素是整 //型的,所以P是一个由整型数据组成的数组 int *p[3]; //首先从P处开始,先与[]结合,因为其优先级

//比*高,所以P是一个数组,然后再与*结合,说明 //数组里的元素是指针类型,然后再与int结合, //说明指针所指向的内容的类型是整型的,所以 //P是一个由返回整型数据的指针所组成的数组 int (*p)[3]; //首先从P处开始,先与*结合,说明P是一个指针 //然后再与[]结合(与"()"这步可以忽略,只是为 //了改变优先级),说明指针所指向的内容是一个 //数组,然后再与int结合,说明数组里的元素是 //整型的.所以P是一个指向由整型数据组成的数 //组的指针 int **p; //首先从P开始,先与*结合,说是P是一个指针,然 //后再与*结合,说明指针所指向的元素是指针,然 //后再与int结合,说明该指针所指向的元素是整 //型数据.由于二级指针以及更高级的指针极少用 //在复杂的类型中,所以后面更复杂的类型我们就 //不考虑多级指针了,最多只考虑一级指针. int p(int); //从P处起,先与()结合,说明P是一个函数,然后进入 //()里分析,说明该函数有一个整型变量的参数 //然后再与外面的int结合,说明函数的返回值是 //一个整型数据

相关文档
最新文档