指针是什么？

客官°小女子只卖身不卖艺 2022-05-20 06:15 150阅读 0赞

指针是什么？

当我们说“人”这个词时，有时指的是“人类”如：“人是一种会笑的动物”，有时则指个体：比如“张三这人”。

“指针”这个要念也一样，它可以意指“指针类型”，也可以代表某个具体的“指针变量”。下面我们重点要讲的是：“什么叫指针变量”。

所以这一小节的题目其实应是：“指针变量是什么？”

“指针变量”是什么？诚如其名，它首先是一个变量。

变量最重要的特性是什么？那就是它可以存储一个值。比如：

下面是三行代码，行号是我为了表达方便而特意加上的，并不在实际代码中出现。

*(1)   int a;*

*(2)   a = 100;*

*(3)   a = 200;*

第（1）行定义了一个变量：a。现在它存储的那个值的大小是不定的，因为我们还没有赋给它具体的值呢。

到了（2）行执行以后，a 就存了一个值，这个值多大？答：100。

这里举的是一个整型变量，但其实无论是什么类型的变量，都是用来存值的。

并且，变量的值可以在以后改变大小，比如第（3）行，a中存放的值成了200。

回忆完普通变量的特性，现在说“指针变量”。

指针也是变量，所以也是用于存储一个值。重点是，它存储的这个值，意义有点特别。

指针存储的不是普通的一个值，而是另外一个变量的地址。

一句话：指针是一种用于储存“另外一个变量的地址”的变量。或者拆成两句：指针是一个变量，它的值是另外一个变量的地址。

这就是指针变量与其它的变量的同与不同：的都是一个变量，都用来存储一个值；但，指针存放的是另外一个变量的地址。

可以这样打个比方：

有一间房子，它的地址是：人民路108号。这个房子相当于一个变量。那么：

一、如果它是普通变量，则房子里可能今天住的是张三，明天住的是李四。张三，李四就是这个变量的值。通过访问这间房子，我们可以直接找到张三或李四。

二、如果它是一个指针变量，则房子里不住具体的人，而是放一张纸条，上面写：“南京东路77号”。

“南京东路77号”是一个什么东西？是一个地址。

通过该地址，我们继续找，结果在“南京东路77号”里找到张三。

变量的存储的值可以改变，指针变量的值同样可以变更：

过一天，我们再去访问这个房子，纸条变了“珠海路309号”，通过它，我们找到的是另一个人。

图解：

![pointer.gif][]

能够说出图中两个“20000007”的关系吗？

本质就这点不同，同样是变量，同样要占用一定大小的内存空间，不同的是普通变量在那个内存里，存储了一个具体的值；而指针变量存放的是另一个变量的地址。

不过，什么叫“变量的地址”？只要你是一直跟着我们的课程学习到这里，相信你能明白什么叫变量的“地址”。否则，您可以需要从第一章从头看起了。

说到这里，我们其实一直在说的是“指针变量”，而不是“指针类型”。指针也需要类型，它所存储的那个变量类型，就称为指针的类型。继续前面的比方，有一天我们去人民路108号，今天纸条写着的地址是：“美眉街8号”，于是我们兴冲冲地去了……结果“美眉街8号”里住着一头猪！是不是很失落——我们以为是“人类”，并且是“美眉”，未料却关着一头“猪类”？！

计算机虽然不懂得什么叫“失落”，但为了它的准确性，我们需要事先定义好一个指针到底是放的是什么类型的变量。这个类型通常也当作是该指针的类型。

“指针变量中存储某变量的地址”这种说法是不是有些绕？所以有一个简短的说法：“指针指向某一变量”。

这种说法的缺陷是不能像第一种说法好样道出指针的本质。但它确实方便。下面我们将不断的使用这两种说法，大家需要知道它们具有相同意义。

### *19.2 *指针的大小 ###

指针的大小是问：一个指针变量占用多少内存空间？

分析：既然指针只是要存储另一个变量的地址，。注意，是存放一变量的地址，而不是存放一个变量本身，所以，不管指针指向什么类型的变量，它的大小总是固定的：只要能放得下一个地址就行！（这是一间只有烟盒大小的“房间”，因为它只需要入一张与着地址的纸条）。

存放一个地址需要几个字节？答案是和一个* int *类型的大小相同：4字节。

所以,若有：

*int\* pInt;*

*char\* pChar;*

*bool\* pBool;*

*float\* pFloat;*

*double\* pDouble;*

则*:* *sizeof(pInt)*、sizeof(pChar)、sizeof(pBool)、*sizeof(pFloat)*、sizeof(pDouble)的值全部为：4。

（你敢拆电脑吗？拆开电脑，认得硬盘数据线吗？仔细数数那扁宽的数据线由几条细线组成？答案：32条，正是* 4 \* 8*）。

我们这一章有很多上机实验。这就算是第一个，只是我提供了代码：请写一个程序，验证上面关于*sizeof(T \*)*的结论。在写程序之前，务必要先参考一下“数据结构”这一章中*sizeof*的例子。

### *19.3 *定义一个指针变量 ###

数据类型*\* * 变量名*;*

或：

数据类型*  \**变量名*;*

和申请一个普通变量相比，只是在数据类型后面多了一个星号。比如：

*int\* p;*

星号也可以靠在变量名前面，如：

*int \*p;*

要同时定义多个相同类型的指针，则为：

*int \*p1, \*p2;*

注意，每个变量之前都必须有 \* 。

### *19.4 *初始化指针变量 ###

是变量就存在一个初始化的问题。一个不能确定是住着什么人的房间，总是有点恐怖。

#### *19.4.1 *指向不明的指针 ####

我先定义一个整型指针：

*int\* p;*

现在，p是一个指针，*int *规定它只能存放整型变量的地址*,*而不是其它如字符型，布尔型等等。

我们称：p 是一个整型指针。

不过，现在 p* *指向哪里 （即：*p *存储的是哪个变量的地址 ）？

变量在没有赋值之前，其值不定的。对于指针变量，值不定可以表述为：指向不明。

重点来了！ 一个指向不明的指针，是一个危险的家伙。很多软件有BUG，其最后的原因，就在这里。

来看看下而的“恐怖片”：

<table style="border-spacing:0px;color:rgb(51,51,51);font-family:'-apple-system', 'SF UI Text', Arial, 'PingFang SC', 'Hiragino Sans GB', 'Microsoft YaHei', 'WenQuanYi Micro Hei', sans-serif, SimHei, SimSun;font-size:14px;background-color:rgb(193,230,198);border-color:rgba(0,0,0,.35);"> 
 <tbody> 
 <tr style="border-top-color:rgba(0,0,0,.35);background-color:rgb(193,230,198);"> 
 <td>你来到一间阴森森的房间，这房间里有一张纸条</td> 
 <td style="border-color:rgba(0,0,0,.35);">---&gt;</td> 
 <td>打开火折，但见纸条内容：“XXX街3K号”</td> 
 <td style="border-color:rgba(0,0,0,.35);">---&gt;</td> 
 <td>你前往这纸条的神秘地址……</td> 
 <td style="border-color:rgba(0,0,0,.35);">---&gt;</td> 
 <td>“XXX街3K号”里住着一千年老妖！你……</td> 
 </tr> 
 <tr style="border-top-color:rgba(0,0,0,.35);background-color:rgb(193,230,198);"> 
 <td style="border-color:rgba(0,0,0,.35);">程序访问了一个没有初始化的指针：int* p;</td> 
 <td style="border-color:rgba(0,0,0,.35);">p&nbsp;的内存是随机的一个数，比如：&nbsp;0x3FF0073D</td> 
 <td style="border-color:rgba(0,0,0,.35);">程序随即访问内存地址：&nbsp;0x3FF0073D</td> 
 <td style="border-color:rgba(0,0,0,.35);">0x3FF0073D&nbsp;是哪里的内存？说不定正好是Windows老大要用的内存，你竟敢访问！Windows一生气，蓝屏。</td> 
 </tr> 
 </tbody> 
</table>

既然没有赋值的指针这么危险，下面来看看如何给指针赋值。

#### *19.4.2 *给指针变量赋值 ####

* *

*(1)        int k = 100;*

*(2)        int\* p;*

*(3)        p = &k;*   //p取得变量*k*的地址 （也称：p指向k）

第1行定义一个整型变量k。

第2行定义了一个整型指针p。

而第3行，“指针 p 存储了变量k的地址”。短的说法是“*p*指向了*k*”。

执行了上面三行代码后，结果是： p 指向 k。我们来看具体的内存示意图。

![ls19.h1.gif][]

*p *指向 *k *示意图

上图中，红色数字代表什么？红数字11000002 是 变量 k 的内存地址。

指针初始化的结果，就是让它存储下另一个变量的地址。简称指向另一个变量。

下面说说三种常见的，给指针赋值的操作：

一、用* & *取得普通变量的地址。

要想让指针指向某个普通变量，需要通过* & *来得到该普通变量的地址。

*int k;*

*int\* p = &k;*

二、指针之间的赋值。

两个指针之间也可以相互赋值，此时不需要通过* & *来取址。

*int k;*

*int\* p1*

*int\* p2;*

*p1 = &k;*  //*p1 *先指向* k*

*p2 = p1;  //*然后 ，p2 也指向* *k。

注意，*p2 = p1*的结果是：让p2也指向“p1所指的内容”，而不是让p2指向“p1本身”。

上面的情况可以改为直接在定义时就赋值：

*int k;*

*int\* p1 = &k;*

*int\* p2 = p1;*

三、让指针指向数组

数组本身就是地址，所以对数组变量也不用通过 *& *来取址。

*char name\[\] = "NanYu";*

*char\* p = name;  //*不用取址符* &*

或者：

*int arr\[3\] = \{100,99,80\};*

*int\* p = arr; *

四、让指针指向一个新地址

前而的赋值方法都是让指针指向一个已有的内存空间的地址。比如：*int\* p = &k*； 指针变量*p* 存放的是已有的变量k的地址。其实指针也可以指向一个新开辟的内存空间，这一内存空间不归属于其它变量。

在C++中，常用一个关键字：*new *来为指针开辟一段新空间。比如：

*int\* p = new int;*

现在，指针变量p存储着一个内存地址，该内存地址确实存在——它是由 *new *操作符申请而得。可以这样认为，*new *是一位特权人物，不通过它，指针只能指向已有的“房间”；而使用了它，则可以要求系统为指针“新开辟一片空地，然后建上新房间”。

有特权的人不仅仅是“new”，还有几个系统定义的函数，及*Windows*提供的函数，都可以实现“向系统要空间”的功能。我们将在后面专门的 章节详细讲解。

### 1*9*.5 地址解析 及其操作符* \** ###

*\* *在C,C++语言里除了起“乘号”的作用以外，前面我们还刚学了它可以在定义变量时，表明某个变量是属于“指针类型”。现在，则要讲到它还能起“地址解析”的作用。

什么叫“地址解析”？假设有一* int *类型变量k：

*int k = 100;*

方框是变量k所占用的内存。100 是该内存中存放的值。而* 11000000* 则是该内存的地址。

“地址解析”就是 地址\-*>*值 的解释过程。即：通过地址 *11000000 *得到位于地址的变量。

可见“地址解析（\*）” 和 “取址（*&*）” 正好是一对相反的操作。

这好有一比：地址解析符 \* 是个邮递员，他要根据信封上的地址，找到实际的房子。而 取址符 *& *则是当初到你家抄下门牌号的人。

看一下实际应用例子：

*int k = 100;*

*int\* p = &k;*

*int m = \*p;*

*cout << m << endl;*

执行以上代码，屏幕上将输出 100。

实际上也可以这样写，以取得相同结果：

*int k = 100;*

*int\* p = &k;*

*cout << \*p << endl;*

直接输出* \*p *即可。\*p 的值就是* 100.*

明白了吗？ *p = &k *让p得到k的地址，而 \*p 则得到k的值。

下面就考一考你* & *和* \** 的作用。

*int k = 100;*

*cout << \*&k << endl;*

将会输出什么？

通过地址解析得到变量，不仅仅可以“得知”该变量的值，还可直接修改该变量的值。

*int k = 100;*

*int\* p = &k; //p *指向k

*\*p = -100;*

*cout << k << endl;*

屏幕上将输出 -100。

### *19.6 *上机实验一 指向普通变量的指针和指针之间的互相赋值 ###

实验一有多个步骤。

第一步、将上面的代码片段变成程序。请大家打开CB，新建空白控制台工程，然后输入以下代码。

*1) int k = 100;*

*2) int\* p1 = &k;*

*3) cout << \*p1 << endl;*

*4) system("PAUSE");*

*(*行前的编号是为下面讲课方便，你当然不能将它们输入到CB中去。*)*

运行将查看结果。然后按任意键退出该程序。下面我们要亲眼看看，指针变量p1，是否真的存放着普通变量k的地址。

把断点设在第*2*行上。*(*输入光标移到第二行，然后按F5*)*

![ls19.h2.gif][]

（设置断点）

按F9运行，程序停在断点上，然后按* Ctrl + F7 *调出*"Evaluate/Modify" *对话框。该对话框可以在程序运行时观察或强行修改某个变量的值。我们这里仅是想看看变量 k 的地址。所以如图输入 *&k* ，回车后，*Result*（结果）栏出现：0012FF88。这就是k的地址。

*![ls19.h2.jpg][]*

*(&k *的值就是* k *的内存地址*)*

接下来我们该看 p1 的值。看它是否等于* 0012FF88*。删除* &k *，改为* p*1，回车，怎么回事？CB竟然很不配合地显示p1的值为 00000100 ？呵，这是因为当前断点那一行还没有运行呢，p1现在的值是随机的，这验证好我们前面说的“指向不明”。

![ls19.h3.gif][]

*(*还没有初始化的指针p1，随随便便指向一个莫名的地址*)*

关掉该对话框，然后按F8再运行一步。再按* Ctrl + F7 *调出上面窗口，输入* p1,*回车，这回显示的的值正合我们的推想。

![ls19.h4.gif][]

（p1 的值，就是* k *的地址，即：*p1 *等于 *&k*）

第二步、基于前一题，再加上一个指针变量，叫* p2*。

*1) int k = 100;*

*2) int\* p1 = &k;*

*3) int\* p2 = p;*

*4) cout << \*p1 << endl;*

*5) cout << \*p2 << endl;*

编译并运行，观察结果应发现，*\*p *和* \*p2 *值相等，为什么？因为二者指向同一变量：k。

第三步、请像第一步一样，观察，k 的地址，及p1， p2 的值。看三者是否相等。

最后*,*将后面的两行输出删除，改为以下两行代码。第一行输出 k 的地址、p1、p2的值。

第二行 输出k的值、\*p1、\*p2 值。

//cout << \*p1 << endl;

//cout << \*p2 << endl;

cout << "&k = " << &k << ", p1 = " << p1 << ", p2 = " << p2 <<endl;

cout << "k = " << k << ", \*p1 = " << \*p1 << ", \*p2 = " << \*p2 <<endl;

运行后结果如下：

![ls19.h5.jpg][]

*(1245064 *是十进制的，它等于十六进制的* 0x0012FF88)*

### *19.7 *上机实验二：改变指针所指变量的值，改变指针的指向 ###

尽管在上面的例子中修修改改也能改成本例，不过枝节太多的代码不会混淆了我们的目的。这次我们重点在于“改变”。

第一步、 通过指针，改变其所指向的变量的值。（好绕啊！代码却很简单）

*int k = 100;*

*int\* p = &k;*

*//*先输出一开始的k和\*p的值*(*用逗号分开*)*：

*cout << k << "," << \*p << endl; *

*//*现在直接改变k值：

*k = 200;*

*//*输出此时的二者的值：

*cout << k << "," << \*p << endl; *

*//*然后通过指针来改变k值：

*\*p = 300;*

*//*输出此时的二者的值：

*cout << k << "," << \*p << endl; *

*system("PAUSE");*

输出将是：

![ls19.h6.gif][]

可见，当p指向k以后，修改 \*p 的值完全等同于直接修改 k值。

第二步、改变指针的指向

所谓的“改变指向”，其实就是“改变指针变量中存储的值（另一个变量的地址）”。我们一开始说的，两种不同的说法而已。

在前面的代码最后，我们加上以下代码：

*...*

*int m = 1000;*

*//*现在p改为指向变量* *m* :*

*p = &m;*

* k = 400;*

*cout << k << "," << m << "," << \*p << endl; 
　*

*\*p = 2000;*

*cout << k << "," << m << "," << \*p << endl;*

*system("PAUSE");*

屏幕输出是：

![ls19.h7.gif][]

当p改为指向m以后，之前指向的k便再也和它没有什么关系了。改变k值不会再影响p；而改变p值，则影响到m值而非k值。

### *19.8 *指针的加减操作 ###

整型变量可以加减，求和，求差：

*int a = 100;*

*int b = 99;*

*int c = a - b;*

而指针，由于它存的是一个内存地址，那么我们可以想到，对两个指针进行求和，求差，是没有意义的。想想，把你家的门牌号（206）和对面的的门牌号（207）相加（413），得到的数有什么意义吗？

那么，指针的加减指什么呢？主要是指移动（而不是联通：（）。比如，你家是206，那么，你的下一家，应该是206 + 1 = 207，而上一家则是206 - 1 = 205。你会说，我们这里的门牌号不是这样编的。但不管如何，大致应当是一个等差关系，或其它规律。都可以通过不断加上一个数，来得到下一家。

#### *19.8.1 *指向数组的指针 ####

现在，来说说指针指向一个数组的情况。

*int arr\[\] = \{1,2,3,4,5\}; //*一个数组

*int\* parr; //*一个指针。

*parr = arr; //*没有* *‘*&*’* *？对啊，对数组就是不用取址符。

*cout << \*parr << endl;  //*输出* \*parr*

先猜想一下，输出结果是什么？

最“直觉”的想法是：*parr *指向一个数组，那么输出时，自然是输出数组中的所有元素了。所以答案应该是：“12345”了？

不过，我想，学过前面的数组，我们就能知道这种想法错误。

正确答案是输出数组中的第一个元素： 1 。

接下来，如果是这样输出呢？

*parr = arr;*

*cout << parr << endl;*

答案是输出了*arr*的地址。就等同于输出* arr* 。

*cout << arr << endl;* 的作用

在这里，难点是要记住，数组变量本身就是地址。所以有：

1、想让指针变量存储一个数组的地址（想让指针变量指向一个数组）时，不用取址符。

2、解析一个指向数组的指针，得到的是数组的第一个元素。

我们来看示意图：

![ls19.h9.gif][]

（指向数组的指针）

尽管数组中的每一个元素都有自已的地址，然而一个指向数组的指针，它仍然只是存储数组中第一个元素的地址。复习数组的章节，我们知道，数组中第一个元素的地址，就是数组的地址。即上图中的* 10000010*。

事实上，如果我们想故意让代码很难理解，则对于这一句：

*parr = arr;*

可以改为：

*parr = &arr\[0\];*

本来嘛， arr 和* &arr\[0\] *的值就相等，我们在数组的章节已经学过。你若不信，可以输出一个：

*cout << arr << "," << &arr\[0\] << endl;*

#### *19.8.2 *上机实验三：指向数组的指针 ####

int arr\[2\] = \{1,2\};

int\* p = &arr\[0\];

//输出：指向数组的指针，数组的地址，数组中第一个元素的地址。

cout << p << "," << arr << "," << &arr\[0\] << endl;

system("PAUSE");

结果是：

![ls19.h10.gif][]

*(*指向数组的指针，数组的地址，数组中第一个元素的地址。*)*

#### *19.8.3 *偏移指针 ####

请看前图的这一部分：

![ls19.h11.gif][]

*parr *中存的值为 “10000010”。

指针可以进行加减操作。假设我现在再定义一个指针：

*int\* parr2;*

*parr2 = parr + 1;*

现在问，*parr2 *的值是多少？有两种答案。一种说，* parr *存的值是* 10000010 *，加1后，自然应为* 10000011*了。这看似自然的答案又是错误了。

正确答案：*10000014*。继续看前图另一小部分：

![ls19.h12.gif][]

（加1后，指针指向了下一个元素）

加1后，指针指向了下一个元素。由于这是一个* int *类型的数组，每个元素的大小是4个字节。所以第二个元素的地址是10000014。

重点 *& *易错点：对指针 进行加1操作，得到的是下一个元素的地址，而不是原有地址值直接加1。

知到了如何“加”，也就知道了如何“减”。减以后，得到的是上一个元素的大小。

所以，一个类型为 T 的指针的移动，以 *sizeof(T) *为移动单位。

比如：

*int\* pInt; *移动单位为 *sizeof(int) *。即：4。而* char\* pChar; *移动单位为* sizeof(char)*。即1。

试举一例：

#### *19.8.4 *上机实验四：指针的最小移动单位 ####

*int arr\[6\] = \{101,102,103,104,105,106\};*

*int\* pI = arr;*

*cout << "pI *是一个指向整型数组的指针，移动单位*:*4字节*" << endl;*

*for (int i = 0; i < 6; i++)*

*   cout << "pI + " < " << pI + i << ", \*(pI + i) = "  << \*(pI + i) << endl;  *

*cout << "------------------------------------" << endl;*

*//*接下 来是一个指向*char*类型数组的指针：

*char str\[4\] = \{'a','b','c','d'\}*

*char\*  pC = str;*

*cout << "pC *是一个指向字符数组的指针，移动单位*:1*字节*" << endl;*

*for (int i=0; i < 4; i++)*

*    cout << "pC + " < " << (int)(pC + i) << ", \*(pC + i) = "  << \*(pC + i) << endl;  *

*system("PAUSE");*

输出结果：

![ls19.h5.gif][]

*(*指针的最小移动单位*)*

每一行中，程序先输出指针加上偏移量以后的值（地址），比如：1245024、1245028；然后输出偏移后指针指向的值，比如101，102。

查看移动前后指针存储的地址，我们就可以计算出移动单位。1245028 - 1245024 = 4 （byte）。

现在，我们回头再来看这道题：

有以下代码，设* arr *的地址是*  10000010*，请问最终* *指针变量*part2*的值是多少？

*int arr\[\] = \{1,2,3,4\};*

*int\* parr1 = arr;*

*int\* parr2;*

*int\* parr2 = parr + 1;*

答案： *10000010 + sizeof (int) = 10000014*。

这就是对指针加减操作的规则：假设某指针类型为 T\* ，则该指针的最小移动单位为：* sizeof(T)*。

即，若有：

*T\* p;*

则* p + n = p + sizeof(T) \* n;* 及：* p - n = p - sizeof(T) \* n;*

#### *19.8.5 *指针的 *+= *、* -= *、++、 -- 操作 ####

C、C++ 除了“传统”的* +,- *操作以外，还提供了如题的四种加减操作。这些对于指针同样适用。

*int arr\[\] = \{1,2,3,4,5,6,7,8,9,10\};*

*int\* parr1 = arr;*

*parr1 += 1; //*向后称动一个单位

*parr1 += 1*； 的结果，相当于： * parr1 = parr1 + 2;*

我们再前面的例子是： *parr2 = parr1 + 2;* 所以计算结果赋值给*parr2,*所以* parr2 *指向了*parr1 *所指的下一个元素的位置。parr1本身仍然指在第一个元素。

但对于* parr1 += 1 *或* parr1 = parr1 + 2;* 则改变的是* parr1*自身的值。

现在，如果来加一句：

*parr1 -= 1; //*向前移动一个单位

则* parr1 *又回到* arr *数组的开始位置。

也可以直接移动2个或更多个单位：

*parr1 = arr;*

*parr1 += 2;  //parr1 *现在指向：元素* 3*

*parr1 -= 2;  //parr1 *现在又回到了* *元素 1 上面

\++ 和 -- 操作* *运算结果等同于 *+= 1 *和* -= 1*。

*//*后置：

*parr1++;*

*parr1--;*

//前置：

*++parr1;*

*--parr1;*

前置与后置的区别，请复习我们第一次讲 ++ 和 --的章节内容。这时仅举一例，用两段代码来对比，请大家思考，并且最好把它写成实际程序运行。

#### *19.8.6 *上机实验五：指针的前置++与后置++的区别 ####

*//*代码片段一：

*int arr\[\] = \{1,2,3,4,5,6,7,8,9,10\};*

*int\* parr1 = arr;*

*int A = \*parr1++;*

*int B = \*parr1;*

*cout << "A = " << A << endl;*

*cout << "B = " << B << endl;*

输出结果：

*A = 1;*

*B = 2;*

代码片段二：

*int arr\[\] = \{1,2,3,4,5,6,7,8,9,10\};*

*int\* parr1 = arr;*

*int A = \*++parr1;*

*int B = \*parr1;*

*cout << "A = " << A << endl;*

*cout << "B = " << B << endl;*

输出结果：

*A = *2*;*

*B = 2;*

#### *19.8.7 *\* （地址解析符）与 ++ 的优先级 ####

从上例中我们可以看到。当* \** （作为地址解析符）* *和* ++ *同时作用在指针时，不管是前置还是++，都要比\*有更高的优先级。比如代码中的：

*int A = \*parr++;*

我们来一个反证：假设\*的优先级比++高，那么，应先计算：

*\*parr *结果为： *1 *（第一个元素）

然后计算*  1++ *，结果为：2。

但实验发现结果为 1，这个1 又是如何来的呢？有点复杂。

首先，++优先计算，所以应先计算：*parr++ *。

结果是*parr*指向了下一个元素：2。因为这是后置++，所以，它必须返回自己计算之前的值；所以，在改变*parr*之前，编译程序会生成一个临时变量，计算原先*parr*的值。我们假设为* old\_parr *。下面是第二步操作：

*A = \*old\_parr*。

由于* old\_parr *是* parr* 原来的值，指向第一个元素，所以* A *得到值： 1 。

可见，后置 ++ 或 后置*-- *操作，需要系统生成一个临时变量。

如果这个变量占用的内存空间很小*(*比如指针类型总是只有4字节*)*，则该操作带来的，对程序速度的负面影响可以不计，如果变量很大，并且多次操作。则应在可能的情况下，尽量使用前置++或前置--操作。

你自然会问，前置++就不会产生临时变量吗？我们来试试。

*int A = \*++parr;*

同样，++优先级大于\*，所以先计算：*++parr*。

结果*parr *指向下一个元素。因为这是前置++，所以，它只需要返回的，正是自己计算之后的值。下一步是：

*A = \*parr;*

由于* parr *此时已完成++操作，指向下一个元素。所以 A 得到值： 2* *。

#### *19.8.8 *上机实验六：指针的 ++与--操作 ####

*int arr \[\] = \{1,2,3,4,5\};*

*int\* parr = arr;*

*//*前进* ++*：

*for (int i=0; i < 5; i++) //*如果为了优化，你可以写成：* ++i :)*

*\{*

*   cout << \*parr << endl;*

*   parr++;   //*如果为了优化，你可以写成：*++parr :D*

* *

*   /\**

*     *上面两句你还可以写成一句：* *

*     cout << \*parr++ << endl;  //*这里，你可不能为了优化写成：* \*++parr.*

*  \*/*

*\}*

*//*后退 --：

*for (int i=0; i < 5; i++)*

*\{*

*   parr--;*

*   cout << \*parr << endl;*

*\}*

输出结果：

![ls19.h8.gif][]

（指针的++与--）

### *19.9 *小结 ###

指针是什么？不过也是一个变量，只是存储的是另一个变量的内容地址。

指针有多大？总是4字节。

如何定义指针？ 多了一个\*。

如何为指针赋值？全靠一个个*&*，除非对方已经是地址（如对方也是指针或是一个数组）。

如何得到指针所指的变量？如何通过指针改变所指变量？地址解析符：\*。

如何移动指针？加加减减。

[pointer.gif]: /images/20220520/f50ce4109f4b4905a5a0dacafb941a67.png
[ls19.h1.gif]: /images/20220520/be1b48f1844a41c99ec398e13538259e.png
[ls19.h2.gif]: /images/20220520/85c2ae012e504db6bb10ed274c12c3a3.png
[ls19.h2.jpg]: /images/20220520/f690d8d02e914453bec9a63bc5064b64.png
[ls19.h3.gif]: /images/20220520/2775f4beb98741ceb4968d2fa8537de9.png
[ls19.h4.gif]: /images/20220520/f371250b2cbd463c8268bf131833335f.png
[ls19.h5.jpg]: /images/20220520/8da6e0672ba0433f87e329da32cb0a48.png
[ls19.h6.gif]: /images/20220520/e6d2e6e39b2f46cd8060955019f1eb8d.png
[ls19.h7.gif]: /images/20220520/2fe9c2f00552473d86f9672edb68f932.png
[ls19.h9.gif]: /images/20220520/d358f64a81d949cf8c8b9e96a01e2e27.png
[ls19.h10.gif]: /images/20220520/16faa9074b0d4d129d2cf0fc02038cb9.png
[ls19.h11.gif]: /images/20220520/2cb20d22c07548b5a0c7736d3ab87881.png
[ls19.h12.gif]: /images/20220520/26e3eac1d02a49a1abde6073c51063dd.png
[ls19.h5.gif]: /images/20220520/d97c0c9f9fde47ec9212a061cf05f834.png
[ls19.h8.gif]: /images/20220520/425e1fc2b17843f8b63b4d96b5284bc2.png