指针变量的运算

指针变量的运算有三种：赋值运算、关系运算与算术运算。

1. 指针变量赋值运算就是将变量的地址赋给指针变量

2. 指针变量的算术运算

指针变量的算术运算主要有指针变量的自加、自减、加n和减n操作。

（1）指针变量自加运算

指令格式：<指针变量>++;

指针变量自加运算并不是将指针变量值加1的运算，而是将指针变量指向下一个元素的运算。

当计算机执行 <指针变量>++ 指令后，指针变量实际增加值为指针变量类型字节数.

即：<指针变量>=<指针变量>+sizeof(<指针变量类型>)。

int *p=&a[0]; //p=1000，指向a[0]元素
p++; 
//第一条语句将数组a的首地址1000赋给指针变量p，使p=1000。
//第二条语句使p作自加运算：p=p+sizeof(int)=p+4=1004，使p指向下一个元素a[1] 。

（2）指针变量自减运算

指令格式：<指针变量>--;

指针变量的自减运算是将指针变量指向上一元素的运算。

当计算机执行 <指针变量>-- 指令后，指针变量实际减少为指针变量类型字节数，即：

<指针变量>=<指针变量>- sizeof(<指针变量类型>)

自加运算和自减运算既可后置，也可前置。

（3）指针变量加n运算

指令格式：<指针变量>=<指针变量>+n;

指针变量的加n运算是将指针变量指向下n个元素的运算。

当计算机执行 <指针变量>+ n 指令后，指针变量实际增加值为指针变量类型字节数乘以n，

即：<指针变量>=<指针变量>+sizeof(<指针变量类型>)*n

（4）指针变量减n运算

指令格式：<指针变量>=<指针变量>- n;

指针变量的减n运算是将指针变量指向上n个元素的运算。

当计算机执行 <指针变量>― n 指令后，指针变量实际减少值为指针变量类型字节数乘以n，

即：<指针变量>=<指针变量>―sizeof(<指针变量类型>)*n

3．指针变量的关系运算

指针变量的关系运算是指针变量值的大小比较，即对两个指针变量内的地址进行比较，主要用于对数组元素的判断。

4．指针运算符的混合运算与优先级

（1）指针运算符* 与取地址运算符&的优先级相同，按自右向左的方向结合。

设有变量定义语句： int a, *p=&a; 

则表达式：&*p 的求值顺序为先"*"后"&"，即& (*p)=&a=p 。

而表达式：*&a 的求值顺序为先"&"后"*"，即* (&a)=*p=a 。

（2）"++"、"--"、"*"、"&"的优先级相同，按自右向左方向结合。下面结合例子加以说明。

设有变量定义语句：

int a[4]={100,200,300,400},b;
int * p=&a[0]; 

为了叙述方便，假设系统给数组a分配的首地址为1000

① b=*p++; 

按自右向左结合的原则，表达式 *p++ 求值序顺为先"++"后"*"，即：*(p++)。

由于"++"在p之后为后置++运算符，所以表达式的实际操作是先取*p值，后进行p++的自加操作。

即赋值表达式 b=*p++; 等同于下面两条语句： 

b=*p; // b=*p=a[0]=100
p++; //p=p+sizeof(int)= 1004

最后运算的结果为b=100,p=1004指向a[1]。

② b=*++p; 

按自右向左结合的原则，表达式 *++p 求值顺序为先"++"后"*"，即：*(++p)。

由于++在p之前为前置++运算符，所以表达式的实际操作是进行++p的自加操作，后取*p值。

即赋值表达式 b=*++p; 等同于下面两条语句：

++p; //p=p+sizeof(int)= 1008，指向a[2]
b=*p; // b=*p=a[2]=300
//最后运算的结果为b=300,p=1008指向a[2]。

③ b=(*p)++; 

由于括号内优先运算，所以表达式先取出*p（即a[2]）的值并赋给b，然后将*p的值即a[2]内容加1。

所以表达式等同于下面两条语句：

b=*p; //b=a[2]=300 
a[2]++ ; // a[2]=300+1=301

④ b=*(p++); 

由①可知，该表达式等同于*p++，运算结果为：

b=*p; //b=a[2]=301
p++; // p=p+sizeof(int)=1012，指向a[3]

⑤ b=++*p ;

该表达式先进行"*"运算，再进行"++"运算，即先取出*p的值，再将该值加1。

因此表达式实际进行了如下运算：b=++(*p)=++a[3]=400+1=401; p仍指向a[3]不变。

#include "stdafx.h"
#include "iostream"
using namespace std;

int main()
{
	int a[4]={100,200,300,400},b;
	int *p=&a[0];
	cout<<"p="<<p<<endl<<endl;
	b=*p++;
	cout<<"b=*p++\t\tb="<<b<<"\t\t"<<"p="<<p<<endl;
	b=*++p;
	cout<<"b=*++p\t\tb="<<b<<"\t\t"<<"p="<<p<<endl;
	b=(*p)++;
	cout<<"b=(*p)++\tb="<<b<<"\t\t"<<"p="<<p<<endl;
	b=*(p++);
	cout<<"b=*(p++)\tb="<<b<<"\t\t"<<"p="<<p<<endl;
	b=++*p;
	cout<<"b=++*p\t\tb="<<b<<"\t\t"<<"p="<<p<<endl<<endl;
	for(int i=0;i<4;i++)
	{
		printf("a[%d] = %d\n",i,a[i]);
	}
	system("pause");
	return 0;
}

结果显示：

说明：在定义数组时，数据a的地址是由操作系统存储管理动态分配的，因此，数组a的地址是不确定的，每次运行的结果都可能会不同。一般用十六进制数表示。