*p++和*++p的区别

问题的起因是复习《数据结构》，看到顺序线性表的查找元素函数时

int LocateElem_Sq(SqList L,ElemType e,Status (*compare)(ElemType,ElemType))
//在顺序线性表L内查找第一个与e相等的元素
//返回其位序
{
	i = 1;//i的初值为第一个元素的位序
	p = L.elem;//p的初值为顺序
	while(i<=L.length&&!(*compare)(*p++,e))++i;//此处的*p++究竟是怎样的结合顺序？
	if(i<=L.length)return i;
	else return 0;

}

下面这篇博文给我以解答
转自http://blog.youkuaiyun.com/npy_lp/article/details/6927302

 接下来，通过示例彻底理解自增运算符的两种用法（自减的用法与之类似，只不过是加1变成了减1）。

    1、++i和i++的区别

    如清单1（注意代码中的注释）： 

[cpp]  view plain copy

1. #include <stdio.h>  
2.   
3. int main(void)  
4. {  
5.     int a, b, i = 7;  
6.   
7.     i++; //等价于i = i + 1;  
8.     ++i; //等价于i = i + 1;  
9.   
10.     a = i++; //等价于a = i; i = i + 1;  
11.     b = ++i; //等价于i = i + 1; b = i;  
12.       
13.     printf("a = %d, b = %d\n", a, b);  
14.       
15.     return 0;  
16. }  

    例子输出结果： 

[cpp]  view plain copy

1. a = 9, b = 11  

    在例子中，第7和第8行的作用一样，仅仅是为变量i加1，这时i的值已经增加为9，接下来第10行变量a先获得i的值（即9），然后i加1，第11行变量i先再加1，然后把得到的值赋给b，所以b的值为11。

    稍微复杂的例子，如清单2： 

[cpp]  view plain copy

1. #include <stdio.h>  
2.   
3. int main(void)  
4. {  
5.     int a = 5;  
6.   
7.     int *p = &a;  
8.   
9.     int b = (*p)++; //等价于b = a++; 即b = a; a = a + 1;  
10.   
11.     int c = ++(*p); //等价于c = ++a; 即a = a + 1; c = a;   
12.       
13.     printf("b = %d, c = %d\n", b, c);  
14.   
15.     printf("(*p)++ = %d, ++(*p) = %d\n", (*p)++, ++(*p));  
16.   
17.     return 0;  
18. }  

    例子输出结果： 

[cpp]  view plain copy

1. b = 5, c = 7  
2. (*p)++ = 8, ++(*p) = 8  

    在这个例子中，只不过是通过*p来间接地操作a，其他关于自增运算符的用法与清单1类似。第9行的*p一定要用小括号括起来，否则含义就不一样了。而第11行的++（*p）也可以写成++*p（用GCC验证过），那是因为对操作数p来说它只有一个运算符*在计算它，所以无关乎运算符优先级和结合性的问题。

    值得注意的是，由于C语言没有指定函数各参数的求值顺序，所以第15行的代码是不可移植的，用不同的编译器可能会产生不同的结果（对于这个例子，GCC是先计算++（*p），后计算（*p）++，所以两者都等于8）。

    知识点：

    （1）、副作用

    在对表达式求值的同时，修改了某些变量的值，其中修改值的行为在C语言中被叫作副作用，那是因为对C语言而言，计算的目的就是对表达式求值，如语句int a = 5，它的含义是先求值得到5，然后把5赋值给变量a，后一步的赋值就是此表达式的副作用。自增和自减运算符就是因为副作用而被使用，除了加1或减1之外，还给自身赋值。

    （2）、运算符的优先级

    在C语言中，把运算符的优先级分为15级，如下表，从上到下，依次为从最高优先级到最低优先级（为了方便记忆，将15级分成11类，并对每类进行了命名）。

初等运算符	包括小括号 ()、中括号 [] 、成员访问运算符 . 和 -> 。
一元运算符	包括自增++和自减--、正负号+ 和-、间接运算*和取址运算& 、类型转换(type)、 sizeof 、逻辑反! 、位取反~等。
算术运算符	包括两级，先乘除（*、/、%）后加减（+、-）。
位移运算符	包括左移 << 和右移 >> 。
关系运算符	包括小于 < 、小于等于 <= 、大于 > 、大于等于 >= 。
判等运算符	包括相等 == 和不相等 != 。
位逻辑运算符	分三级，依次为位与 &、位异或 ^ 和位或 | 。
逻辑运算符	分两级，依次为逻辑与 && 和逻辑或 || 。
条件运算符	? :
赋值运算符	包括= 、+= 、-=、 *=、 /=、 %= 、&= 、^=、 |= 、<<= 、>>= 。
逗号运算符	，

    （3）、结合性

    对于同一操作数，在具有两个相同优先级的操作符时决定先执行哪个操作符的问题就是由结合性决定的。

    相同优先级的操作符具有同样的结合性。右结合性就是说表达式中最右边的操作最先执行，然后从右到左依次执行。在C语言中，具有右结合性的操作符只有相应的三类，分别为一元运算符、条件运算符和赋值运算符。

    注意：C语言中的优先级和结合性都是针对同一操作数而言的。如表达式24/8*2，对于操作数8而言，/ 和*的优先级相同，所以再根据它们的左结合性可知，表达式是先计算24/8得到3，然后计算3*2得到6。

    C语言并没有规定同一运算符相关的多个操作数的计算顺序（&&、|| 、? : 和 , 运算符除外），如式子a = 8 * 9 + 20 * 4，对操作数9和20而言，根据优先级就可判断先乘后加，但表达式中的两个*并不共享同一操作数，所以从左到右的结合性并不适用它，8 * 9 和20 * 4的计算顺序是不定的，到底先计算8 * 9还是20 * 4由编译器决定。

    在上面例子中，8 * 9和20 * 4谁先执行都不影响最后结果的一致，但有些情况下就未必了，如“ b = 3; a = (b++) * (b++); ”这样的例子，对于不同的编译器最后a的值可能等于9，也可能等于12，甚至可能等于16。因此，在实际应用中不能出现这样的未确定性，根据自己的需要，可以把它改成类似“b = 3; c = b++; a = c * c;”这样的形式。

    2、*p++和*++p的区别

    举例，如清单3： 

[cpp]  view plain copy

1. #include <stdio.h>  
2.   
3. int main(void)  
4. {  
5.     int arr[] = {1, 2, 3, 4};  
6.     int *p = arr;  
7.   
8.     int a = *p++; //等价于a = *(p++); 即a = *p; p = p + 1;  
9.       
10.     int b = *++p; //等价于b = *(++p); 即p = p + 1; b = *p;  
11.       
12.     printf("a = %d, b = %d\n", a, b);  
13.   
14.     return 0;  
15. }  

    例子输出结果： 

[cpp]  view plain copy

1. a = 1, b = 3  

    对于第8行的操作数p而言，*和++的优先级相同，但根据它们的右结合性可知，在这个表达式里可认为++的优先级高于*，即*p++等价于*(p++)。

    而对于第10行的操作数p而言，它只有一个运算符++，所以先计算++p得出结果，然后间接运算。