C语言指针小白一问

Posted 2023-03-17

main()

int a=2, *p = &a, *q = &a;
printf("%d %d\n",*p++,*(q++));



其中 *(q++) 的运算顺序是先算 ++,然后再算 * 吗?

*p++ 也是先算 ++ 再计算 * 吗?

麻烦大家帮解答

你的问题归结为对C运算符的优先级不清楚。
好好看以下的，估计以后在运算符的优先级上你是不会出什么问题的。
一、赋值运算符
赋值语句的作用是把某个常量或变量或表达式的值赋值给另一个变量。符号为‘=’。这里并不是等于的意思，只是赋值，等于用‘==’表示。
注意：赋值语句左边的变量在程序的其他地方必须要声明。
得已赋值的变量我们称为左值，因为它们出现在赋值语句的左边；产生值的表达式我们称为右值，因为她它们出现在赋值语句的右边。常数只能作为右值。
例如：
count=5;
total1=total2=0;
第一个赋值语句大家都能理解。
第二个赋值语句的意思是把0同时赋值给两个变量。这是因为赋值语句是从右向左运算的，也就是说从右端开始计算。这样它先total2=0;然后total1=total2;那么我们这样行不行呢？
(total1=total2)=0;
这样是不可以的，因为先要算括号里面的，这时total1=total2是一个表达式，而赋值语句的左边是不允许表达式存在的。

二、算术运算符
在C语言中有两个单目和五个双目运算符。
符号 功能
+ 单目正
- 单目负
* 乘法
/ 除法
% 取模
+ 加法
- 减法
下面是一些赋值语句的例子， 在赋值运算符右侧的表达式中就使用了上面的算术运算符：
Area=Height*Width;
num=num1+num2/num3-num4;
运算符也有个运算顺序问题，先算乘除再算加减。单目正和单目负最先运算。
取模运算符(%)用于计算两个整数相除所得的余数。例如：
a=7%4;
最终a的结果是3，因为7%4的余数是3。
那么有人要问了，我要想求它们的商怎么办呢？
b=7/4;
这样b就是它们的商了，应该是1。
也许有人就不明白了，7/4应该是1.75，怎么会是1呢？这里需要说明的是，当两个整数相除时，所得到的结果仍然是整数，没有小数部分。要想也得到小数部分，可以这样写7.0/4或者7/4.0，也即把其中一个数变为非整数。
那么怎样由一个实数得到它的整数部分呢？这就需要用强制类型转换了。例如：
a=(int) (7.0/4);
因为7.0/4的值为1.75，如果在前面加上(int)就表示把结果强制转换成整型，这就得到了1。那么思考一下a=(float) (7/4);最终a的结果是多少？
单目减运算符相当于取相反值，若是正值就变为负值，若是负数就变为正值。
单目加运算符没有意义，纯粹是和单目减构成一对用的。

三、逻辑运算符
逻辑运算符是根据表达式的值来返回真值或是假值。其实在C语言中没有所谓的真值和假值，只是认为非0为真值，0为假值。
符号 功能
&& 逻辑与
|| 逻辑或
! 逻辑非
例如：
5!3;
0||-2&&5;
!4;

当表达式进行&&运算时，只要有一个为假，总的表达式就为假，只有当所有都为真时，总的式子才为真。当表达式进行||运算时，只要有一个为真，总的值就为真，只有当所有的都为假时，总的式子才为假。逻辑非(!)运算是把相应的变量数据转换为相应的真/假值。若原先为假，则逻辑非以后为真，若原先为真，则逻辑非以后为假。
还有一点很重要，当一个逻辑表达式的后一部分的取值不会影响整个表达式的值时，后一部分就不会进行运算了。例如：
a=2,b=1;
a||b-1;
因为a=2，为真值，所以不管b-1是不是真值，总的表达式一定为真值，这时后面的表达式就不会再计算了。

四、关系运算符
关系运算符是对两个表达式进行比较，返回一个真/假值。
符号 功能
> 大于
< 小于
>= 大于等于
<= 小于等于
== 等于
!= 不等于
这些运算符大家都能明白，主要问题就是等于==和赋值=的区别了。
一些刚开始学习C语言的人总是对这两个运算符弄不明白，经常在一些简单问题上出错，自己检查时还找不出来。看下面的代码：
if(Amount=123) ……
很多新人都理解为如果Amount等于123，就怎么样。其实这行代码的意思是先赋值Amount=123，然后判断这个表达式是不是真值，因为结果为 123，是真值，那么就做后面的。如果想让当Amount等于123才运行时，应该if(Amount==123) ……

五、自增自减运算符
这是一类特殊的运算符，自增运算符++和自减运算符--对变量的操作结果是增加1和减少1。例如：
--Couter;
Couter--;
++Amount;
Amount++;

看这些例子里，运算符在前面还是在后面对本身的影响都是一样的，都是加1或者减1，但是当把他们作为其他表达式的一部分，两者就有区别了。运算符放在变量前面，那么在运算之前，变量先完成自增或自减运算；如果运算符放在后面，那么自增自减运算是在变量参加表达式的运算后再运算。这样讲可能不太清楚，看下面的例子：
num1=4;
num2=8;
a=++num1;
b=num2++;

a =++num1;这总的来看是一个赋值，把++num1的值赋给a，因为自增运算符在变量的前面，所以num1先自增加1变为5，然后赋值给a，最终a也为5。b=num2++;这是把num2++的值赋给b，因为自增运算符在变量的后面，所以先把num2赋值给b，b应该为8，然后num2自增加1变为 9。
那么如果出现这样的情况我们怎么处理呢？
c=num1+++num2;
到底是c=(num1++)+num2;还是c=num1+(++num2);这要根据编译器来决定，不同的编译器可能有不同的结果。所以我们在以后的编程当中，应该尽量避免出现上面复杂的情况。

六、复合赋值运算符
在赋值运算符当中，还有一类C/C++独有的复合赋值运算符。它们实际上是一种缩写形式，使得对变量的改变更为简洁。
Total=Total+3;
乍一看这行代码，似乎有问题，这是不可能成立的。其实还是老样子，'='是赋值不是等于。它的意思是本身的值加3，然后在赋值给本身。为了简化，上面的代码也可以写成：
Total+=3;
复合赋值运算符有下列这些：
符号 功能
+= 加法赋值
-= 减法赋值
*= 乘法赋值
/= 除法赋值
%= 模运算赋值
<<= 左移赋值
>>= 右移赋值
&= 位逻辑与赋值
|= 位逻辑或赋值
^= 位逻辑异或赋值
上面的十个复合赋值运算符中，后面五个我们到以后位运算时再说明。
那么看了上面的复合赋值运算符，有人就会问，到底Total=Total+3;与Total+=3;有没有区别？答案是有的，对于A=A+1，表达式A被计算了两次，对于复合运算符A+=1，表达式A仅计算了一次。一般的来说，这种区别对于程序的运行没有多大影响，但是当表达式作为函数的返回值时，函数就被调用了两次(以后再说明)，而且如果使用普通的赋值运算符，也会加大程序的开销，使效率降低。

七、条件运算符
条件运算符(?:)是C语言中唯一的一个三目运算符，它是对第一个表达式作真/假检测，然后根据结果返回两外两个表达式中的一个。
<表达式1>?<表达式2>:<表达式3>
在运算中，首先对第一个表达式进行检验，如果为真，则返回表达式2的值；如果为假，则返回表达式3的值。
例如：
a=(b>0)?b:-b;
当b>0时，a=b；当b不大于0时，a=-b；这就是条件表达式。其实上面的意思就是把b的绝对值赋值给a。

八、逗号运算符
在C语言中，多个表达式可以用逗号分开，其中用逗号分开的表达式的值分别结算，但整个表达式的值是最后一个表达式的值。
假设b=2,c=7,d=5,
a1=(++b,c--,d+3);
a2=++b,c--,d+3;
对于第一行代码，有三个表达式，用逗号分开，所以最终的值应该是最后一个表达式的值，也就是d+3，为8，所以a=8。对于第二行代码，那么也是有三个表达式，这时的三个表达式为a2=++b、c--、d+3,(这是因为赋值运算符比逗号运算符优先级高)所以最终表达式的值虽然也为8，但a2=3。

还有其他的如位逻辑运算符，位移运算符等等，我们等到讲位运算时再说明。

九、优先级和结合性
从上面的逗号运算符那个例子可以看出，这些运算符计算时都有一定的顺序，就好象先要算乘除后算加减一样。优先级和结合性是运算符两个重要的特性，结合性又称为计算顺序，它决定组成表达式的各个部分是否参与计算以及什么时候计算。
下面是C语言中所使用的运算符的优先级和结合性：
优先级 运算符 结合性
(最高) () [] -> . 自左向右
! ~ ++ -- + - * & sizeof 自右向左
* / % 自左向右
+ - 自左向右
<< >> 自左向右
< <= > >= 自左向右
== != 自左向右
& 自左向右
^ 自左向右
| 自左向右
&& 自左向右
|| 自左向右
?: 自右向左
= += -= *= /= %= &= ^= |= <<= >>= 自右向左
(最低) , 自左向右
在该表中，还有一些运算符我们没有介绍，如指针运算符、sizeof运算符、数组运算符[]等等，这些在以后的学习中会陆续说明的。 参考技术A 加括号就是优先括号内的运算，所以*(q++) 的运算顺序是先算 ++,然后再用*取得指针变量间接指向的变量。

这里的int a=2, *p = &a, *q = &a; 声明了整形变量a；指针变量p，并且 把a的地址赋给p，也就是说p间接指向a；q也是指针变量，跟p是一摸一样的。

需要输出的：*p++和*(q++)：
*p++,是先*p优先，它的值也就是p指向的a，a＋＋就是a＋1。但是！要注意，a＋＋这种写法是“先用后加”，所以，输出的是a的值，之后a再自加1，因此输出的是2。
*(q++)这个的运算顺序虽然是先括号内的，但也是"先用后加"，也就是间接取得了a的值，因此也是输出2。

参考资料：原创

参考技术B ()是优先运算符，有了当然先算括号内的。
如果没有就从左到右运算，先*本回答被提问者采纳 参考技术C ++运算符的优先顺序就是先引用变量的值再进行++运算，所以*p++先引用p的值，再++，而加了（）就清晰的表明了改变运算顺序的意图，所以在这里先++后引用运算后的p值 参考技术D 楼上都不对吧。++比取值运算优先级高，可是后置的++却是先使用后加1的。所以这里加不加括号都是先取值，再增量指针。

指针的深度剖析（小白模式）

指针详解

• 初级指针
• • 1. 指针是什么
  • 2. 指针和指针类型
  • 3. 野指针
  • 4. 指针运算
  • 5. 指针和数组
  • 6. 二级指针
• 指针的进阶
• • 1. 字符指针
  • 2. 数组指针
  • 3. 指针数组
  • 4. 数组传参和指针传参
  • 5. 函数指针
  • 6. 函数指针数组
  • 7. 指向函数指针数组的指针
  • 8. 回调函数
  • 9. 指针和数组面试题的解析

初级指针

1. 指针是什么

指针是什么？

• 在计算机科学中，指针（Pointer）是编程语言中的一个对象，利用地址，它的值直接指向（points to）存在电脑存储器中另一个地方的值。由于通过地址能找到所需的变量单元，可以说，地址指向该变量单元。因此，将地址形象化的称为“指针”。
• 指针就是变量，用来存放地址的变量（存放内存单元的地址）
  
  代码举例

#include <stdio.h>
int main()
{
 	int a = 10;//在内存中开辟一块空间
 	int *p = &a;//这里我们对变量a，取出它的地址，可以使用&操作符。
   //将a的地址存放在p变量中，p就是一个之指针变量。
 	return 0; 
 }

我们知道了指针是用来存放内存单元的地址，但指针的大小我们还不知道，请接着看下面

一个小的单元到底是多大的字节那？

答案：一个字节

编址过程
对于32位的机器，假设有32根地址线，那么假设每根地址线在寻址的是产生一个电信号正电/负电（1或 者0）
那么32根地址线产生的地址就会是：
00000000 00000000 00000000 00000000
00000000 00000000 00000000 00000001
…
111111111 111111111 111111111 111111111
每个地址标识一个字节，这里就有（2^32Byte == 2^32/1024KB ==
2^{32/1024/1024MB==2}32/1024/1024/1024GB == 4GB） 4G的空闲进行编址。
64位机器类推
所以在32位的机器上，地址是32个0或者1组成二进制序列，那地址就得用4个字节的空间来存储，在64位上地址就得用8个字节的空间来存储。
所以在32位机器上，指针占4个字节，64位机器上，指针占8个字节。

2. 指针和指针类型

首先，C语言有多种不同的内置数据类型，当然也有相关指针的类型，指针类型如下：

char  *pc = NULL; //指向char型的指针
int   *pi = NULL; //指向整形的指针
short *ps = NULL; //指向short型的指针
long  *pl = NULL; //指向long型的指针
float *pf = NULL; //指向单精度浮点型的指针
double *pd = NULL;//指向双精度浮点型的指针

那指针类型存在的意义是什么？

指针的类型决定了指针向前或者向后走一步有多大（距离）。

看下面的例子：

#include <stdio.h>
//演示实例
int main()
{
	 int n = 10;
	 char *pc = (char*)&n; //这里截断，数据存储里面讲到了的
	 int *pi = &n;
	 
	 printf("%p\\n", &n);//n的地址
	 printf("%p\\n", pc);//n的一个字节的地址
	 printf("%p\\n", pc+1);//往下一个地址走
	 printf("%p\\n", pi);//n的地址
	 printf("%p\\n", pi+1);//n下一个内存空间的地址，跟n一样（4个字节）
	 return  0; 
}

指针的解引用

//演示实例
#include <stdio.h>
int main()
{
 int n = 0x11223344;
 char *pc = (char *)&n;
 int *pi = &n; 
 *pc = 0;   //重点在调试的过程中观察内存的变化。
 *pi = 0;   //重点在调试的过程中观察内存的变化。
 return 0; }

通过调试可以看到内存地址的一些变化。（根据类型不同内存地址会有变化）
总之：指针的类型决定了，对指针解引用的时候有多大的权限（能操作几个字节）。

3. 野指针

野指针就是指针指向的位置是不可知的（随机的、不正确的、没有明确限制的）
野指针出现的原因：

• 1.指针未初始化

#include <stdio.h>
int main()
{ 
	int *p;//局部变量指针未初始化，默认为随机值
    *p = 20;
	return 0; 
}

• 2.指针越界访问

#include <stdio.h>
int main()
{
    int arr[10] = {0};
    int *p = arr;
    int i = 0;
    for(i=0; i<=11; i++)
   {
        //当指针指向的范围超出数组arr的范围时，p就是野指针（越界相当于未初始化）
        *(p++) = i;
   }
    return 0; 
}

• 3.指针指向的空间释放

	char *Ptr = NULL;
	Ptr = (char *)malloc(100 * sizeof(char));
	if (NULL == Ptr) //检查指针的有效性
	{
	exit (1);
	}
	//如果不继续使用该指针，需要对char型Ptr指针进行的空间释放
	//加上free(Ptr)释放空间，最后置为NULL，避免形成野指针
	//如果没加，就会造成指针指向位置不明确，也就成了野指针。

如何避免野指针

• 1.指针初始化
• 2.小心指针越界访问
• 3.指针指向空间释放即使置NULL
• 4.指针使用之前检查有效性

4. 指针运算

指针±整数

	float values[5];
	float *vp=NULL;
	//指针+-整数；指针的关系运算
	for (vp = &values[0]; vp < &values[5];)
	{
	     *vp++ = 0; }
	//这里通过指针的+整数，将values数组的每个值都初始化为0了

指针-指针

int my_strlen(char *s) {
       char *p = s;
       while(*p != '\\0' )
              p++;
       return p-s; }//通过p指针找到s指针的末尾，然后p-s计算字符串s的长度

指针的关系运算

for(vp = &values[4]; vp >= &values[0];vp--)
{
    *vp = 0; }

标准规定：
允许指向数组元素的指针与指向数组最后一个元素后面的那个内存位置的指针比较，但是不允许与指向第一个元素之前的那个内存位置的指针进行比较。

5. 指针和数组

数组名是数组首元素的地址

#include <stdio.h>
int main()
{
 int arr[10] = {1,2,3,4,5,6,7,8,9,0};
    printf("%p\\n", arr);
    printf("%p\\n", &arr[0]);
    return 0; }

结果显示如下：

那么我们可以通过指针来访问数组中的元素

	int arr[10] = { 1,2,3,4,5,6,7,8,9,0 };
	int* p = arr;//通过指针指向数组首元素地址
	int len = sizeof(arr) / sizeof(arr[0]);
	for (int i = 0; i < len; i++)
	{
		printf("%d %p\\n", *(p + i),p + i);
	}

通过p指针输出结果：

地址显示：

这里的p+i，虽然i是增加的1，但内存地址中其实是跳的4个字节（也就是一个整形），而非这里的 i ，所以才能依次访问数组中的元素（注意区分！！！）
所以 p+i 其实计算的是数组 arr 下标为i的元素的地址

6. 二级指针

指针变量也是变量，也有地址，所以二级指针用来存放指针变量的地址。

	int a = 10;
	int* p = &a;//存放a的地址
	int** pa = &p;//存放指针变量p的地址
	*pa = &a;
	**pa = 20;
	//等价于*p = 30;
	//等价于a = 30;
	printf("%d %d %d", a, *p, **pa);

• *pa通过对pa的地址进行解引用，这样找到的是p，*pa就是访问的p
• **pa先通过*pa找到p，然后对p进行解引用操作：*p，找到的就是a
  

指针的进阶

1. 字符指针

2. 数组指针

3. 指针数组

4. 数组传参和指针传参

5. 函数指针

6. 函数指针数组

7. 指向函数指针数组的指针

8. 回调函数

9. 指针和数组面试题的解析