您所在位置： &
&nbsp&&nbsp&nbsp&&nbsp
C语言中指针变量的用法.pdf 3页
本文档一共被下载：
次 ,您可全文免费在线阅读后下载本文档。
下载提示
1.本站不保证该用户上传的文档完整性，不预览、不比对内容而直接下载产生的反悔问题本站不予受理。
2.该文档所得收入(下载+内容+预览三)归上传者、原创者。
3.登录后可充值，立即自动返金币，充值渠道很便利
需要金币：120 &&
你可能关注的文档：
··········
··········
--------------------------Page1------------------------------实践与经验／／文章编号：(41—03DOI：10．3969／j．issn．．0C语言中指针变量的用法周二强．张妍琰(河南城建学院计算机科学与工程学院，平顶山467036)摘要：C语言中使用指针变量时通常需两步：第一步为指针变量赋值，把某个存储单元的地址存人与指针变量相关的存储单元中，即让指针变量指向某个存储单元；第二步以间接引用的方式使用指针变量指向的存储单元利用变量直接使用存储单元时，存储单元的使用范围受限于变量的作用域，而通过指针变量以间接引用的方式可以扩展存储单元的使用范围。以间接引用方式使用的存储单元不仅可以是基本数据类型的、数组等，而且可以是没有变量标识的堆空间上的存储单元．甚至还可以是与代码相关的“函数类型”的存储单元关键词：指针；存储单元：C语言1指针变量与普通变量的异同类似intj=i；，语句int*pj=pi；N以使整型指针变量pJ也存储了变量i的地址．即整型指针变量pJ也指向了整变量标识了计算机内存中的存储单元．用于存储型变量i。但表达式pi+3实为一个地址加3，对于不熟数据。存储单元是内存块在C语言中的抽象．具有固定悉的地址数据．只有定义了加法的意义才能确定计算的大小，分类型，某类存储单元只能存放一种数据语结果。句inti；21~义了一个变量i．它对应于一个整型(int)存储单元，只能存储一个整数(int)，变量i可称为整型(int)内容变量变量。指针变量也是变量．因此．它们也标识了存储单元，也用于存储数据。与普通变量存储常见数据不同．指针变量用于存储地址地址是存储单元在计算机中的5编号．用于定位存储单元。在C语言定义语句中用星号表示地址，例如语句intpi；定义一个变量pi，它对应于rl_]H厂——5—]I一个整型指针(int)存储单元．只能存储一个整型存储I．．．．．．．．．．．．．．．．．．I．．．．．．．．．．．．．．．．．__llj单元的地Jak(int)，可称变量pi为整型指针变量。0Ol2ffo0pi形象地表示语句i=5：可以把整数5存入与变量i相关的存储单元中语句pi=&i：可以把与变量i相关的整型存储解码后的原始状态单元的地址存入与变量pi相关的存储单元中，此时常形象地称指针变量pi指向了变量i。它们在内存中的图1相关变量存储状态简图状态可用图1简单地表示在程序中可以通过变量i直接使用相关的存储单程序中使用指针变量通常并非关注其存储的数元，例如表达式i+3实为5+3，值为8指针变量pi保存据，因为地址只用于标识存储单元，下面分析C语言中了变量i的地址。使用指针变量通常表现为使用地址引人指针变量的真正目的。现代计算机2014．02上--------------------------Page2------------------------------2指针变量的作用3指针变量可以指向的存储单元的类型如图1所示．当指针变量pi指向变量i时，表达式指针变量指向的存储单元可以是普通的类型．如pi也标识了变量i相关的存储单元，即在使用存储单有doublef=2．3；doublepf-&f．，则pf与f标识了同一元时既可以用变量i，也可以用pi。通过变量i直接使块存储单元。用存储单元的方式称为直接引用：由于操作符是间接引用操作符，故称通过表达式pi使用存储单元的方式为间接引用直接使用的方式虽然简便但受变量作2用域的限制只要获得了存储单元的地址就能以问接3引用的方式使用存储单元．间接引用的方式可以扩展存储单元的使用范围。以下面的程序为例：#include&stdio．h&0x0012ffO0pxvoidswap(intpx．intPY)OxOO12ff04py{inttemp；temppx；px=py；图2相关变量的状态py=temp；}指针变量指向的存储单元可以是数组．如有intaintmain()[3]={1，2，31；int(pa)[3】=&a；，则pa与a标识了同一{块存储单元。(pa)[0】与a[O】标识了同一块存储单元，值inti=2，j=3；为1。swap(&i，＆j)；指针变量指向的存储单元可以是指针类型的存储printf(”％d，％d＼n”，i，j)；单元，如有inti=2，pi=&i；int料ppi=&pi；，则指向整型retumO：指针变量的指针变量ppi存储了整型指针变量Di的地}址，*ppi与pi标识了同一块存储单元，语句intpj=由于变量i的作用域局限于main函数中．因此只ppi；与语句intpj=pi；作用相同，
正在加载中，请稍后...在c语言中，指针变量中，假如前面已经定义了指针变量*p，在函数中对*p赋值，那么*p=&a 与 p=&a 这两种赋值有什么区别？
本回答由提问者推荐
var sogou_ad_id=731547;
var sogou_ad_height=160;
var sogou_ad_width=690;65647人阅读
下面用通俗易懂的话来概述一下：
指针-对于一个类型T，T*就是指向T的指针类型，也即一个T*类型的变量能够保存一个T对象的地址，而类型T是可以加一些限定词的，如const、volatile等等。见下图，所示指针的含义：
引用-引用是一个对象的别名，主要用于函数参数和返回值类型，符号X&表示X类型的引用。见下图，所示引用的含义：
2、指针和引用的区别
首先，引用不可以为空，但指针可以为空。前面也说过了引用是对象的别名，引用为空——对象都不存在，怎么可能有别名！故定义一个引用的时候，必须初始化。因此如果你有一个变量是用于指向另一个对象，但是它可能为空，这时你应该使用指针；如果变量总是指向一个对象，i.e.，你的设计不允许变量为空，这时你应该使用引用。如下图中，如果定义一个引用变量，不初始化的话连编译都通不过（编译时错误）：
而声明指针是可以不指向任何对象，也正是因为这个原因，使用指针之前必须做判空操作，而引用就不必。
其次，引用不可以改变指向，对一个对象&至死不渝&；但是指针可以改变指向，而指向其它对象。说明：虽然引用不可以改变指向，但是可以改变初始化对象的内容。例如就++操作而言，对引用的操作直接反应到所指向的对象，而不是改变指向；而对指针的操作，会使指针指向下一个对象，而不是改变所指对象的内容。见下面的代码：
#include&iostream&
using&namespace&
int&main(int&argc,char** argv)
&&&&int&i=10;
&&&&int& ref=i;
&&&&ref++;
&&&&cout&&&i=&&&i&&
&&&&cout&&&ref=&&&ref&&
&&&&int&j=20;
&&&&ref=j;
&&&&ref++;
&&&&cout&&&i=&&&i&&
&&&&cout&&&ref=&&&ref&&
&&&&cout&&&j=&&&j&&
&&&&return&0;
对ref的++操作是直接反应到所指变量之上，对引用变量ref重新赋值&ref=j&，并不会改变ref的指向，它仍然指向的是i，而不是j。理所当然，这时对ref进行++操作不会影响到j。而这些换做是指针的话，情况大不相同，请自行实验。输出结果如下：
再次，引用的大小是所指向的变量的大小，因为引用只是一个别名而已；指针是指针本身的大小，4个字节。见下图所示：
从上面也可以看出：引用比指针使用起来形式上更漂亮，使用引用指向的内容时可以之间用引用变量名，而不像指针一样要使用*；定义引用的时候也不用像指针一样使用&取址。
最后，引用比指针更安全。由于不存在空引用，并且引用一旦被初始化为指向一个对象，它就不能被改变为另一个对象的引用，因此引用很安全。对于指针来说，它可以随时指向别的对象，并且可以不被初始化，或为NULL，所以不安全。const 指针虽然不能改变指向，但仍然存在空指针，并且有可能产生野指针（即多个指针指向一块内存，free掉一个指针之后，别的指针就成了野指针）。
总而言之，言而总之——它们的这些差别都可以归结为&指针指向一块内存，它的内容是所指内存的地址；而引用则是某块内存的别名，引用不改变指向。&
3、特别之处const
在这里我为什么要提到const关键字呢？因为const对指针和引用的限定是有差别的，下面听我一一到来。
常量指针VS常量引用
常量指针：指向常量的指针，在指针定义语句的类型前加const，表示指向的对象是常量。
定义指向常量的指针只限制指针的间接访问操作，而不能规定指针指向的值本身的操作规定性。
常量指针定义&const int* pointer=&a&告诉编译器，*pointer是常量，不能将*pointer作为左值进行操作。
常量引用：指向常量的引用，在引用定义语句的类型前加const，表示指向的对象是常量。也跟指针一样不能利用引用对指向的变量进行重新赋值操作。
指针常量VS引用常量
在指针定义语句的指针名前加const，表示指针本身是常量。在定义指针常量时必须初始化！而这是引用天生具来的属性，不用再引用指针定义语句的引用名前加const。
指针常量定义&int* const pointer=&b&告诉编译器，pointer是常量，不能作为左值进行操作，但是允许修改间接访问值，即*pointer可以修改。
常量指针常量VS常量引用常量
常量指针常量：指向常量的指针常量，可以定义一个指向常量的指针常量，它必须在定义时初始化。常量指针常量定义&const int* const pointer=&c&告诉编译器，pointer和*pointer都是常量，他们都不能作为左值进行操作。
而就不存在所谓的&常量引用常量&，因为跟上面讲的一样引用变量就是引用常量。C++不区分变量的const引用和const变量的引用。程序决不能给引用本身重新赋值，使他指向另一个变量，因此引用总是const的。如果对引用应用关键字const，起作用就是使其目标称为const变量。即没有：Const double const& a=1；只有const double& a=1；
总结：有一个规则可以很好的区分const是修饰指针，还是修饰指针指向的数据——画一条垂直穿过指针声明的星号（*），如果const出现在线的左边，指针指向的数据为常量；如果const出现在右边，指针本身为常量。而引用本身与天俱来就是常量，即不可以改变指向。
4、指针和引用的实现
我们利用下面一段简单的代码来深入分析指针和引用:
#include&iostream&
using&namespace&
int&main(int&argc,&char** argv)
int& ref=i;
cout&&&x is &&&x&&
int* p=&i;
cout&&&ref = &&&ref&&&, i = &&&i&&
上面的代码用g++ test.c编译之后，然后反汇编objdump -d a.out，得到main函数的一段汇编代码如下：
　　　　push %ebp
e5　　　mov %esp,%ebp
e4 f0&&&&&&& and $0xfffffff0,%esp//为main函数的参数argc、argv保留位置
804871a: 56&&&&&&&&&&& push %esi
804871b: 53&&&&&&&&&&&&push %ebx
804871c: 83 ec 28&&&&&&&&sub $0x28,%esp
804871f: c7 44 24 1c 01 00 00 movl $0x1,0x1c(%esp)&//将0x1存到esp寄存器中，即int i=1
d 44 24 1c& lea 0x1c(%esp),%eax// esp寄存器里的变量i的地址传给eax
804872b: 89 44 24 18&&&&mov %eax,0x18(%esp)//将寄存器eax中的内容（i的地址）传给寄存器中的变量ref，即int& ref=i
804872f: 8b 44 24 18&&&&&&&&mov 0x18(%esp),%eax//将寄存器esp中的ref传给eax，即i的地址
b 00&&&&&&& mov (%eax),%eax//以寄存器eax中的值作为地址，取出值给eax& 44 24 14&&&&&&&&mov %eax,0x14(%esp)&//将寄存器eax中的值传给寄存器esp中的x，即x=ref
8048739: c7 44 24 04 00 89 04 &&&&movl $0xx4(%esp)
8048741: c7 04 24 40 a0 04 08&&&&movl $0x804a040,(%esp)
8048748: e8 cb fe ff ff&&&&call 8048618 &_ZStlsISt11char_traitsIcEERSt13basic_ostreamIcT_ES5_PKc@plt&
804874d: 8b 54 24 14&&&&mov 0x14(%esp),%edx
54 24 04&&&&&&&&mov %edx,0x4(%esp)
04 24&&&&&&&&mov %eax,(%esp)
8048758: e8 5b fe ff ff&&&&call 80485b8 &_ZNSolsEi@plt&
804875d: c7 44 24 04 38 86 04&&&&movl $0xx4(%esp)
04 24&&&&&&&&mov %eax,(%esp)
8048768: e8 bb fe ff ff&&&&call 8048628 &_ZNSolsEPFRSoS_E@plt&//从8768这些行就是执行&cout&&&x is &&&x&&&
804876d: 8b 44 24 18&&&&mov 0x18(%esp),%eax//将寄存器esp中的ref传到eax中
8048771: c7 00 02 00 00 00&&&&movl $0x2,(%eax)&//将0x2存到eax寄存器中
d 44 24 1c&&&&&&&&lea 0x1c(%esp),%eax// esp寄存器里的变量i的地址传给eax
804877b: 89 44 24 10&&&&mov %eax,0x10(%esp) //将寄存器eax中的内容（即i的地址）传到寄存器esp中的p
804877f: 8b 5c 24 1c&&&&&&&&mov 0x1c(%esp),%ebx
b 44 24 18&&&&mov 0x18(%esp),%eax
b 30&&&&&&&&mov (%eax),%esi
8048789: c7 44 24 04 06 89 04&&&&movl $0xx4(%esp)
8048791: c7 04 24 40 a0 04 08&&&&movl $0x804a040,(%esp)
8048798: e8 7b fe ff ff&&&&call 8048618 &_ZStlsISt11char_traitsIcEERSt13basic_ostreamIcT_ES5_PKc@plt&
804879d: 89 74 24 04&&&&mov %esi,0x4(%esp)
04 24&&&&&&&&mov %eax,(%esp)
80487a4: e8 0f fe ff ff&&&&call 80485b8 &_ZNSolsEi@plt&
80487a9: c7 44 24 04 0d 89 04&&&&movl $0xx4(%esp)
04 24&&&&&&&&mov %eax,(%esp)
80487b4: e8 5f fe ff ff &&&&call 8048618 &_ZStlsISt11char_traitsIcEERSt13basic_ostreamIcT_ES5_PKc@plt&
5c 24 04&&&&&&&&mov %ebx,0x4(%esp)
80487bd: 89 04 24&&&&&&&&mov %eax,(%esp)
80487c0: e8 f3 fd ff ff&&&&call 80485b8 &_ZNSolsEi@plt&
80487c5: c7 44 24 04 38 86 04&&&&movl $0xx4(%esp)
80487cc: 08
80487cd: 89 04 24&&&&&&&&mov %eax,(%esp)
80487d0: e8 53 fe ff ff&&&&call 8048628 &_ZNSolsEPFRSoS_E@plt&//这些行就是执行&cout&&&ref = &&&ref&&&,
i = &&&i&&&
80487d5: b8 00 00 00 00&&&&mov $0x0,%eax
80487da: 83 c4 28&&&&&&&&add $0x28,%esp
80487dd: 5b&&&&&&&&&&&&pop %ebx
80487de: 5e&&&&&&&&&&&&pop %esi
80487df: 89 ec&&&&&&&&mov %ebp,%esp
d&&&&&&&&&&&&pop %ebp
80487e2: c3&&&&&&&&&&&&ret
从汇编代码可以看出实际上指针和引用在编译器中的实现是一样的：
引用int& ref=i;&
d 44 24 1c&&&&&&&&lea 0x1c(%esp),%eax//&esp寄存器里的变量i的地址传给eax
804872b: 89 44 24 18&&&&mov %eax,0x18(%esp)//将寄存器eax中的内容（i的地址）传给寄存器中的变量ref，即int& ref=i
指针int* p=&i;
d 44 24 1c&&&&&&&&lea 0x1c(%esp),%eax// esp寄存器里的变量i的地址传给eax
804877b: 89 44 24 10&&&&mov %eax,0x10(%esp)&//将寄存器eax中的内容（即i的地址）传到寄存器esp中的p
虽然指针和引用最终在编译中的实现是一样的，但是引用的形式大大方便了使用也更安全。有人说：&引用只是一个别名，不会占内存空间？&通过这个事实我们可以揭穿这个谎言！实际上引用也是占内存空间的。
5、指针传递和引用传递
为了更好的理解指针和引用，我们下面来介绍一下指针传递和引用传递。当指针和引用作为函数的函数是如何传值的呢？（下面这一段引用了）
指针传递参数本质上是值传递的方式，它所传递的是一个地址值。值传递过程中，被调函数的形式参数作为被调函数的局部变量处理，即在栈中开辟了内存空间以存放由主调函数放进来的实参的值，从而成为了实参的一个副本。值传递的特点是被调函数对形式参数的任何操作都是作为局部变量进行，不会影响主调函数的实参变量的值。
引用传递过程中，被调函数的形式参数也作为局部变量在栈中开辟了内存空间，但是这时存放的是由主调函数放进来的实参变量的地址。被调函数对形参的任何操作都被处理成间接寻址，即通过栈中存放的地址访问主调函数中的实参变量。正因为如此，被调函数对形参做的任何操作都影响了主调函数中的实参变量。
引用传递和指针传递是不同的，虽然它们都是在被调函数栈空间上的一个局部变量，但是任何对于引用参数的处理都会通过一个间接寻址的方式操作到主调函数中的相关变量。而对于指针传递的参数，如果改变被调函数中的指针地址，它将影响不到主调函数的相关变量。如果想通过指针参数传递来改变主调函数中的相关变量，那就得使用指向指针的指针，或者指针引用。
从概念上讲。指针从本质上讲就是存放变量地址的一个变量，在逻辑上是独立的，它可以被改变，包括其所指向的地址的改变和其指向的地址中所存放的数据的改变。
而引用是一个别名，它在逻辑上不是独立的，它的存在具有依附性，所以引用必须在一开始就被初始化，而且其引用的对象在其整个生命周期中是不能被改变的（自始至终只能依附于同一个变量）。
在中，指针和引用经常用于函数的参数传递，然而，指针传递参数和引用传递参数是有本质上的不同的：
指针传递参数本质上是值传递的方式，它所传递的是一个地址值。值传递过程中，被调函数的形式参数作为被调函数的局部变量处理，即在栈中开辟了内存空间以存放由主调函数放进来的实参的值，从而成为了实参的一个副本。值传递的特点是被调函数对形式参数的任何操作都是作为局部变量进行，不会影响主调函数的实参变量的值。（这里是在说实参指针本身的地址值不会变）
而在引用传递过程中，被调函数的形式参数虽然也作为局部变量在栈中开辟了内存空间，但是这时存放的是由主调函数放进来的实参变量的地址。被调函数对形参的任何操作都被处理成间接寻址，即通过栈中存放的地址访问主调函数中的实参变量。正因为如此，被调函数对形参做的任何操作都影响了主调函数中的实参变量。
引用传递和指针传递是不同的，虽然它们都是在被调函数栈空间上的一个局部变量，但是任何对于引用参数的处理都会通过一个间接寻址的方式操作到主调函数中的相关变量。而对于指针传递的参数，如果改变被调函数中的指针地址，它将影响不到主调函数的相关变量。如果想通过指针参数传递来改变主调函数中的相关变量，那就得使用指向指针的指针，或者指针引用。
为了进一步加深大家对指针和引用的区别，下面我从编译的角度来阐述它们之间的区别：
程序在编译时分别将指针和引用添加到符号表上，符号表上记录的是变量名及变量所对应地址。指针变量在符号表上对应的地址值为指针变量的地址值，而引用在符号表上对应的地址值为引用对象的地址值。符号表生成后就不会再改，因此指针可以改变其指向的对象（指针变量中的值可以改），而引用对象则不能修改。
最后，总结一下指针和引用的相同点和不同点：
★相同点：
●都是地址的概念；
指针指向一块内存，它的内容是所指内存的地址；而引用则是某块内存的别名。
★不同点：
●指针是一个实体，而引用仅是个别名；
●引用只能在定义时被初始化一次，之后不可变；指针可变；引用“从一而终”，指针可以“见异思迁”；
●引用没有，指针有，的指针不可变；（具体指没有int& const a这种形式，而const int& a是有&&&&
的，& 前者指引用本身即别名不可以改变，这是当然的，所以不需要这种形式，后者指引用所指的值不可以改变）
●引用不能为空，指针可以为空；
●“引用”得到的是所指向的变量对象的大小，而“指针”得到的是指针本身的大小；
●指针和引用的自增运算意义不一样；
●引用是类型安全的，而指针不是引用比指针多了类型检查
一、引用的概念
引用引入了对象的一个同义词。定义引用的表示方法与定义指针相似，只是用&代替了*。
例如： Point pt1(10,10);
Point &pt2=pt1; 定义了pt2为pt1的引用。通过这样的定义，pt1和pt2表示同一对象。
需要特别强调的是引用并不产生对象的副本，仅仅是对象的同义词。因此，当下面的语句执行后：
pt1.offset（2，2）；
pt1和pt2都具有（12，12）的值。
引用必须在定义时马上被初始化，因为它必须是某个东西的同义词。你不能先定义一个引用后才
初始化它。例如下面语句是非法的：
Point &pt3；
那么既然引用只是某个东西的同义词，它有什么用途呢？
下面讨论引用的两个主要用途：作为函数参数以及从函数中返回左值。&
二、引用参数
1、传递可变参数
传统的c中，函数在调用时参数是通过值来传递的，这就是说函数的参数不具备返回值的能力。
所以在传统的c中，如果需要函数的参数具有返回值的能力，往往是通过指针来实现的。比如，实现
两整数变量值交换的c程序如下：
void swapint(int *a,int *b)
使用引用机制后，以上程序的c++版本为：
void swapint(int &a,int &b)
调用该函数的c++方法为：swapint（x,y); c++自动把x,y的地址作为参数传递给swapint函数。
2、给函数传递大型对象
当大型对象被传递给函数时，使用引用参数可使参数传递效率得到提高，因为引用并不产生对象的
副本，也就是参数传递时，对象无须复制。下面的例子定义了一个有限整数集合的类：&
const maxCard=100;&
Class Set&
int elems[maxCard]; // 集和中的元素，maxCard 表示集合中元素个数的最大值。&
// 集合中元素的个数。&
Set () {card=0;} //构造函数
friend Set operator * (Set ,Set ) ; //重载运算符号*，用于计算集合的交集 用对象作为传值参数
// friend Set operator * (Set & ,Set & ) 重载运算符号*，用于计算集合的交集 用对象的引用作为传值参数&
先考虑集合交集的实现
Set operator *( Set Set1,Set Set2)
for(int i=0;i&Set1.++i)
for(int j=0;j&Set2.++j)
if(Set1.elems[i]==Set2.elems[j])
res.elems[res.card++]=Set1.elems[i];
由于重载运算符不能对指针单独操作，我们必须把运算数声明为 Set 类型而不是 Set * 。
每次使用*做交集运算时，整个集合都被复制，这样效率很低。我们可以用引用来避免这种情况。
Set operator *( Set &Set1,Set &Set2)
for(int i=0;i&Set1.++i)
for(int j=0;j&Set2.++j)
if(Set1.elems[i]==Set2.elems[j])
res.elems[res.card++]=Set1.elems[i];
三、引用返回值
如果一个函数返回了引用，那么该函数的调用也可以被赋值。这里有一函数，它拥有两个引用参数并返回一个双精度数的引用：
double &max(double &d1,double &d2)
return d1&d2?d1:d2;
由于max()函数返回一个对双精度数的引用，那么我们就可以用max() 来对其中较大的双精度数加1：
max(x,y)+=1.0;
&&相关文章推荐
参考知识库
* 以上用户言论只代表其个人观点，不代表CSDN网站的观点或立场
访问：810281次
积分：7597
积分：7597
排名：第2527名
原创：97篇
转载：105篇
评论：228条
(1)(1)(4)(15)(6)(17)(41)(14)(23)(2)(40)(2)(36)C语言变量的指针和指向变量的指针变量—指针变量的引用_C语言中文网
&&/&&&&/&&
指针变量同普通变量一样，使用之前不仅要定义说明，而且必须赋予具体的值。未经赋值的指针变量不能使用，否则将造成系统混乱，甚至死机。指针变量的赋值只能赋予地址，决不能赋予任何其它数据，否则将引起错误。在Ｃ语言中，变量的地址是由编译系统分配的，对用户完全透明，用户不知道变量的具体地址。
两个有关的运算符：
&:取地址运算符。
*：指针运算符（或称&间接访问& 运算符）。
Ｃ语言中提供了地址运算符&来表示变量的地址。其一般形式为：&变量名；
如&a表示变量a的地址，&b表示变量b的地址。变量本身必须预先说明。
设有指向整型变量的指针变量p，如要把整型变量a 的地址赋予p可以有以下两种方式：
1、指针变量初始化的方法
& & & int *p=&a;
2、赋值语句的方法
& & & int *p;
& & & p=&a;
不允许把一个数赋予指针变量，故下面的赋值是错误的：
& & &int *p;
& & &p=1000;
被赋值的指针变量前不能再加&*&说明符，如写为*p=&a 也是错误的。假设:
& & &int i=200,
& & &int *
我们定义了两个整型变量i,x,还定义了一个指向整型数的指针变量ip。i,x中可存放整数,而ip中只能存放整型变量的地址。我们可以把i的地址赋给ip：ip=&i;
此时指针变量ip指向整型变量i,假设变量i的地址为1800,这个赋值可形象理解为下图所示的联系。以后我们便可以通过指针变量ip间接访问变量i,例如:
运算符*访问以ip为地址的存贮区域,而ip中存放的是变量i的地址,因此,*ip访问的是地址为1800的存贮区域(因为是整数,实际上是从1800开始的两个字节),它就是i所占用的存贮区域, 所以上面的赋值表达式等价于
另外,指针变量和一般变量一样,存放在它们之中的值是可以改变的,也就是说可以改变它们的指向,假设
& & &int i,j,*p1,*p2;
& & &i='a';
& & &j='b';
& & &p1=&i;
& & &p2=&j;
则建立如下图所示的联系。这时赋值表达式:
& & & p2=p1
就使p2与p1指向同一对象i,此时*p2就等价于i,而不是j,图所示。
如果执行如下表达式:
& & & *p2=*p1;
则表示把p1指向的内容赋给p2所指的区域, 此时就变成图所示
通过指针访问它所指向的一个变量是以间接访问的形式进行的,所以比直接访问一个变量要费时间,而且不直观,因为通过指针要访问哪一个变量,取决于指针的值(即指向),例如&*p2=*p1;&实际上就是&j=i;&,前者不仅速度慢而且目的不明。但由于指针是变量,我们可以通过改变它们的指向,以间接访问不同的变量,这给程序员带来灵活性,也使程序代码编写得更为简洁和有效。
指针变量可出现在表达式中, 设
& & & int x,y，*px=&x;
指针变量px指向整数x,则*px可出现在x能出现的任何地方。例如:
& & & y=*px+5;& /*表示把x的内容加5并赋给y*/
& & & y=++*& /*px的内容加上1之后赋给y，++*px相当于++(*px)*/
& & & y=*px++;& /*相当于y=* px++*/
【例10.1】
{ int a,b;
& int *pointer_1, *pointer_2;
& a=100;b=10;
& pointer_1=&a;
pointer_2=&b;
& printf(&%d,%d\n&,a,b);
& printf(&%d,%d\n&,*pointer_1, *pointer_2);
对程序的说明：
在开头处虽然定义了两个指针变量pointer_1和pointer_2，担它们并未指向任何一个整型变量。只是提供两个指针变量，规定它们可以指向整型变量。程序第5、6行的作用就是使pointer_1指向a，pointer_2指向b。
最后一行的*pointer_1和*pointer_2就是变量a和b。最后两个printf函数作用是相同的。
程序中有两处出现*pointer_1和*pointer_2，请区分它们的不同含义。
程序第5、6行的&pointer_1=&a&和 &pointer_2=&b&不能写成&*pointer_1=&a&和 &*pointer_2=&b&。
请对下面再的关于&&&和&*&的问题进行考虑：
如果已经执行了&pointer_1=&a；&语句，则&*pointer_1是什么含义？
*&a含义是什么？
(pointer_1)++和pointer_1++的区别？
【例10.2】输入a和b两个整数，按先大后小的顺序输出a和b。
{ int *p1,*p2,*p,a,b;
& scanf(&%d,%d&,&a,&b);
& p1=&a;p2=&b;
&&& {p=p1;p1=p2;p2=p;}
& printf(&\na=%d,b=%d\n&,a,b);
& printf(&max=%d,min=%d\n&,*p1, *p2);
推荐文章 TOP10