C指针进阶

最新推荐文章于 2024-02-20 13:17:59 发布

yuyijie_1995

最新推荐文章于 2024-02-20 13:17:59 发布

阅读量129

点赞数

分类专栏： C语言文章标签： C的指针指针进阶

本文链接：https://blog.csdn.net/weixin_39558227/article/details/103449442

版权

C语言专栏收录该内容

25 篇文章 0 订阅

订阅专栏

文章目录

- 读指针

读指针

看见带*的变量名字或者函数名字，都是首先从名称开始（不管其他的符号），然后看其他符号的优先级，这里注意[ ]和()的优先级都是是高于*的，另外没有优先级差异的情况下，从右往左理解带*变量
举例
int *p 先和结合，说明p是一个指针
int *p[3]先和[]结合，说明p是一个数组，再和结合，说明数组里的元素是指针类型再和int结合说明这些指针指向内容是整型
int (*p)[3] 首先从P 处开始,先与*结合,说明P 是一个指针然后再与[]结合,说明指针所指向的内容是一个数组,然后再与int 结合,说明数组里的元素是整型的.所以P 是一个指向由整型数据组成的数组的指针
int **pp是一个指针再与*结合，说明指向的元素是指针，然后再与int结合，说明指向的指针指向的是int类型。
int (*p)(int) 首先p是个指针，然后和（）结合，说明指向一个函数，然后再与括号中的int结合，说明函数有个整型参数，然后再与外面的int结合，说明返回类型是int 所以P 是一个指向有一个整型参数且返回类型为整型的函数的指针
int *(*p(int))[3] 首先p是先和()结合，说明p是个函数，再和括号中的int结合，该函数参数是int，再和*结合，返回的是一个指针，再和外面的中括号结合，这指针指向的是一个数组，然后再和*结合,说明数组中的元素是指针，然后再和int结合，这些数组中的指针指向的内容是int数据。**所以p是一个参数为一个整数返回一个指向由整型指针变量组成的数组的指针变量的函数。

看见指针立刻要想明白的几件事

指针的类型

只要把指针声明语句的指针名字去掉，剩下的部分就是这个指针的类型。
在这里插入图片描述

指针所指向的类型

当我们通过指针来访问指针所指向的内存区的时候，指针所指向的类型决定了编译器将把那块内存区里的内容当做什么来看待。
只要把指针声明语句中的智者名字和名字左边的指针声明符*去掉，剩下的就是指针指向的类型
在这里插入图片描述
在指针的算数运算中，指针所指向的类型有很大作用。

指针的数值（就是打印指针能得到的）

也是指针所指向的内存区或者地址！！比如-772962384这种数字
是指针本身存储的数组，被编译器当做一个地址，
指针所指向的内存区就是从指针的值所代表的那个内存地址开始，长度为si zeof(指针所指向的类型)的一片内存区。以后，我们说一个指针的值是XX，就相当于说该指针指向了以XX 为首地址的一片内存区域；我们说一个指针指向了某块内存区域，就相当于说该指针的值是这块内存区域的首地址。指针所指向的内存区和指针所指向的类型是两个完全不同的概念。在例一中，指针所指向的类型已经有了，但由于指针还未初始化，所以它所指向的内存区是不存在的，或者说是无意义的。

指针本身所占据的内存区（指针自己的地址）

用sizeof测试一下就行，一般是4个字节（32位平台）
指针本身占据的内存这个概念在判断一个指针表达式（后面会解释）是否是左值时很有用。

指针运算

一个错误例子即可说明

#include<stdio.h> 
int main() 
{ 
char a[20]=" You_are_a_girl"; 
char *p=a; 
char **ptr=&p; 
//printf("p=%d\n",p); 
//printf("ptr=%d\n",a); 
//printf("ptr=%c\n",*p); 
printf("ptr=%d\n",ptr); 
//printf("*ptr=%d\n",*ptr); 
printf("**ptr=%c\n",**ptr); 
ptr++; 
//printf("ptr=%d\n",ptr); 
//printf("*ptr=%d\n",*ptr); 
printf("**ptr=%c\n",**ptr); 
}

误区一、输出答案为Y 和o

误解:ptr 是一个char 的二级指针,当执行ptr++;时,会使指针加一个sizeof(char),所以输出如上结果,这个可能只是少部分人的结果.

误区二、输出答案为Y 和a误解:ptr 指向的是一个char *类型,当执行ptr++;时,会使指针加一个sizeof(char *)(有可能会有人认为这个值为1,那就会得到误区一的答案,这个值应该是4,参考前面内容), 即&p+4; 那进行一次取值运算不就指向数组中的第五个元素了吗?那输出的结果不就是数组中第五个元素了吗?答案是否定的.

正解: ptr 的类型是char **,指向的类型是一个char *类型(注意不是char类型),该指向的地址就是p的地址(&p),当执行ptr++;时,会使指针加一个sizeof(char*),即&p+4;那*(&p+4)指向哪呢（这个地址已经和字符数组毫无关系了，因为ptr一开始只是指向指针p的指针）,这个你去问上帝吧,或者他会告诉你在哪?所以最后的输出会是一个随机的值,或许是一个非法操作.
一个指针ptrold 加(减)一个整数n 后，结果是一个新的指针ptrnew，ptrnew 的类型和ptrold 的类型相同，ptrnew 所指向的类型和ptrold所指向的类型也相同。ptrnew 的值将比ptrold 的值增加(减少)了n 乘sizeof(ptrold 所指向的类型)个字节。就是说，ptrnew 所指向的内存区将比ptrold 所指向的内存区向高(低)地址方向移动了n 乘sizeof(ptrold 所指向的类型)个字节。指针和指针进行加减：两个指针不能进行加法运算，这是非法操作，因为进行加法后，得到的结果指向一个不知所向的地方，而且毫无意义。两个指针可以进行减法操作，但必须类型相同，一般用在数组方面，不多说了。

&和*

&是取地址符号，*是简介运算符
&a 的运算结果是一个指针，指针的类型是a 的类型加个*，指针所指向的类型是a 的类型，指针所指向的地址嘛，那就是a 的地址。

*p的运算结果就五花八门了。总之*p的结果是p 所指向的东西，这个东西有这些特点：它的类型是p 指向的类型，它所占用的地址是p所指向的地址。

指针表达式

例7

int a,b; 
int array[10]; 
int *pa; 
pa=&a; //&a 是一个指针表达式。 
Int **ptr=&pa; //&pa 也是一个指针表达式。 
*ptr=&b; //*ptr 和&b 都是指针表达式。 
pa=array; 
pa++; //这也是指针表达式

如果一个表达式的结果是一个指针，那么这个表达式叫做指针表达式
当一个指针表达式的结果指针已经明确地具有了指针自身占据的内存的话，这个指针表达式就是一个左值，否则就不是一个左值。在例七中，&a 不是一个左值，因为它还没有占据明确的内存。ptr 是一个左值，因为ptr 这个指针已经占据了内存，其实ptr 就是指针pa，既然pa 已经在内存中有了自己的位置，那么ptr 当然也有了自己的位置。

指针和数组的关系

数组的数组名其实也可以看做一个指针,但是这个指针的值是不可修改的！是个常量指针。

int array[10]={0,1,2,3,4,5,6,7,8,9},value; 
value=array[0]; //也可写成：value=*array; 
value=array[3]; //也可写成：value=*(array+3); 
value=array[4]; //也可写成：value=*(array+4);

上例中，一般而言数组名array 代表数组本身，类型是int[10]，但如果把array 看做指针的话，它指向数组的第0 个单元，类型是int* 所指向的类型是数组单元的类型即int。因此array 等于0 就一点也不奇怪了。同理，array+3 是一个指向数组第3 个单元的指针，所以(array+3)等于3。其它依此类推。

字符数组部分

char *str[3]={ 
"Hello,thisisasample!", 
"Hi,goodmorning.", 
"Helloworld"
}; 
char s[80]； 
strcpy(s,str[0]); //也可写成strcpy(s,*str); 
strcpy(s,str[1]); //也可写成strcpy(s,*(str+1)); 
strcpy(s,str[2]); //也可写成strcpy(s,*(str+2));

上例中，str 是一个三单元的数组，该数组的每个单元都是一个指针，这些指针各指向一个字符串。把指针数组名str 当作一个指针的话，它指向数组的第0 号单元，它的类型是char **，它指向的类型是char *。
*str 也是一个指针，它的类型是char *，它所指向的类型是char，它指向的地址是字符串"Hello,thisisasample!"的第一个字符的地址，即’H’的地址。注意:字符串相当于是一个数组,在内存中以数组的形式储存,只不过字符串是一个数组常量,内容不可改变,且只能是右值.如果看成指针的话,他即是常量指针,也是指针常量.

下面总结一下数组的数组名(数组中储存的也是数组)的问题:

声明了一个数组TYPE array[n]，则数组名称array 就有了两重含义：

第一，它代表整个数组，它的类型是TYPE[n]；

第二，它是一个常量指针，该指针的类型是TYPE*，该指针指向的类型是TYPE，也就是数组单元的类型，该指针指向的内存区就是数组第0 号单元，该指针自己占有单独的内存区，注意它和数组第0 号单元占据的内存区是不同的。该指针的值是不能修改的，即类似array++的表达式是错误的。在不同的表达式中数组名array 可以扮演不同的角色。在表达式sizeof(array)中，数组名array 代表数组本身，故这时sizeof 函数测出的是整个数组的大小。

在表达式*array 中，array 扮演的是指针，因此这个表达式的结果就是数组第0 号单元的值。sizeof(*array)测出的是数组单元的大小。

表达式array+n（其中n=0，1，2，…）中，array 扮演的是指针，故array+n 的结果是一个指针，它的类型是TYPE *，它指向的类型是TYPE，它指向数组第n号单元。故sizeof(array+n)测出的是指针类型的大小。在32 位程序中结果是4

指针和结构类的关系

struct MyStruct 
{ 
int a; 
int b; 
int c; 
}; 
struct MyStruct ss={20,30,40};

//声明了结构对象ss，并把ss 的成员初始化为20，30 和40。
struct MyStruct *ptr=&ss;
//声明了一个指向结构对象ss 的指针。它的类型是
//MyStruct *,它指向的类型是MyStruct。

指针类型转换

当我们初始化一个指针或给一个指针赋值时，赋值号的左边是一个指针，赋值号的右边是一个指针表达式。在我们前面所举的例子中，绝大多数情况下，指针的类型和指针表达式的类型是一样的，指针所指向的类型和指针表达式所指向的类型是一样的

float f=12.3; 
float *fptr=&f; 
int *p;

假如我们想让指针p 指向实数f，应该怎么办？
两者不一致，直接赋值的方法是不行的。
p=(int*)&f;
这样强制类型转换的结果是一个新指针，该新指针的类型是TYPE *，它指向的类型是TYPE，它指向的地址就是原指针指向的地址。

而原来的指针p 的一切属性都没有被修改。（切记）

一个函数如果使用了指针作为形参，那么在函数调用语句的实参和形参的结合过程中，必须保证类型一致，否则需要强制转换

指针安全问题

int *ptr; 
ptr=(int *)&s; 
*ptr=1298；

指针ptr 是一个int *类型的指针，它指向的类型是int。它指向的地址就是s 的首地址。在32 位程序中，s 占一个字节，int 类型占四个字节。最后一条语句不但改变了s 所占的一个字节，还把和s 相临的高地址方向的三个字节也改变了。这三个字节是干什么的？只有编译程序知道，而写程序的人是不太可能知道的。也许这三个字节里存储了非常重要的数据，也许这三个字节里正好是程序的一条代码，而由于你对指针的马虎应用，这三个字节的值被改变了！这会造成崩溃性的错误。

char a; 
int *ptr=&a; 
ptr++; 
*ptr=115;

该例子完全可以通过编译，并能执行。但是看到没有？第3 句对指针ptr 进行自加1 运算后，ptr 指向了和整形变量a 相邻的高地址方向的一块存储区。这块存储区里是什么？我们不知道。有可能它是一个非常重要的数据，甚至可能是一条代码。
而第4 句竟然往这片存储区里写入一个数据！这是严重的错误。所以在使用指针时，程序员心里必须非常清楚：我的指针究竟指向了哪里。在用指针访问数组的时候，也要注意不要超出数组的低端和高端界限，否则也会造成类似的错误。

在指针的强制类型转换：ptr1=(TYPE *)ptr2 中，如果sizeof(ptr2的类型)大于sizeof(ptr1 的类型)，那么在使用指针ptr1 来访问ptr2所指向的存储区时是安全的。如果sizeof(ptr2 的类型) 小于sizeof(ptr1 的类型)，那么在使用指针ptr1 来访问ptr2 所指向的存储区时是不安全的。

二维数组

在二维数组中，包括两个一维数组分量，其中一维数组a[0]等同于&a[0][0],
所以*a[0]等同于a[0][0]
可用三种方式表示

int *pa=a[0];
 a[0][0],..a[0][2]..a[1][2]
*a[0],..*(a[0]+2),...*(a[0]+5)
*pa,..*(pa+2)...*(pa+5)

应该注意
1.随时检查当前指针pa指向数组的哪个元素
2.又是可以把数组指针在限定范围内当做整数来运算（不推荐）
尽量不要用数组指针的+，-运算。

二维数组指针

指向数组元素的指针

int n[10];
int *pn=n

此时pn指向数组n的收元素，这里pn=n，pn=&n[0] 。数组名就是一个指向其寿元的一个指针常量

指向数组的指针

float A[2][4];
float(*pa)[4];
pa=A;

此时指针pa指向一维数组A[0] (A[0]有4个元素) ，执行增量运算后，pa++,pa只想了一维数组A[1]

指向数组的指针和指向数组元素的指针的区别

可以发现，虽然指针变量内容都是地址，但指针变量的类型（指向的对象类型）则决定了该地址指向的存储区的大小

float *p=&A[0][0];
float(*pa)[4];
pa=A

虽然这时候指针p和pa指向的地址（指针存储的值）一样，但p是指向一个整型下标变量A[0][0],而pa则是指向整型一维数组A[0]，前者占内存空间可能是4个字节，后者则占了16字节

一个典型字符数组的例子帮助理解

char s[21],*ps=s;
for(int i=0;i<20;i++)
{
s[i]='A'+i;
}
s[20]='\0';
ps++;
cout<<"ps="<<ps<<endl;
ps+=2;
cout<<"ps="<<ps<<endl;
for(ps=&s[19];ps>&s[11];ps-=2)
{
cout<<"*ps="<<*ps<<endl;
cout<<"ps="<<ps<endl;
}