C语言中数组与指针的透彻分析

最新推荐文章于 2024-03-20 16:20:29 发布

路漫漫

最新推荐文章于 2024-03-20 16:20:29 发布

阅读量652

点赞数

分类专栏： c 文章标签：语言 c

c 专栏收录该内容

21 篇文章 0 订阅

订阅专栏

一. 一维数组与指针的关系分析

1.指针与一维数组的定义

指针定义: 指针是包含内存地址的变量，一般的指针变量直接包含特定的值，指针变量包含的是某一特定数据类型的内存地址。

一维数组的定义: 数组是一组连续的内存位置，它们都具有相同的名称和类型。数组名表示数组的首地址。

定义上的区别: 指针是个变量，可以进行加或减运算，可以改变其指向的内存地址值，而数组是个常量，其内存地址的值不可改变。

可见，指针变量里面存放的是地址，数组名表示数组的首地址。因此，既然都有地址，那么它们之间就有着密切的联系。

2. 指针与数组的输出实例

#include <stdio.h>
#include <stdlib.h>
int main(){
char *p;

char a[]={"abcde"};
p=a;
printf("%s/n",p);
printf("%s/n",a);
printf("%c/n",*p);

printf("%s/n",(p+1));
p=&a[1];
printf("%s/n",p);
printf("%c/n",*p+10);
printf("%x/n",a);
printf("%x/n",&a);
printf("*a=%c/n",*a);
printf("%s/n",a+1);
int i;
for(i=0;i<4;i++){
printf("%c/n",*(p+i));
}
return 0;
}

输出值:

abcde

bcde

bf92c016

*a=a

bcde

我们从第1行开始理解一下程序:

char *p; －定义一个字符型的指针变量

char a[]={"abcde"}; －定义一个字符型数组

p=a; －这条语句是很有讲究的，为什么不是p=&a? ,首先等式的左边是一个指针型变量,其类型为char*即字符型变量，那么等式的右边应该也是字符型变量，在C语言中，当数组出现在表达式中，就退化为指针了。这一点，一定要清楚，它是理解C语言中数组与指针关系的精华。所以，表达式的右边退化为指针，即为char*类型，指向数组的首地址。因此，类型就匹配了。那么p=&a为什么不对呢? 如上分析，表达式左边是char*类型，而表达式右边是char(*)[5]类型，是一个指向数组长度为5的数组指针类型。很明显类型不匹配，所以不能是p=&a.

printf("%s/n",p); －打印出字符串abcde,为什么不是abcde的首地址了? 当a的首地址给了p,那么p里面存放的是a的首地址，按理说，应该打印出的是地址值，但在C语言中，printf一遇到地址，就打印出地址里面的内容值，直到/0为止。这一点也是非常重要的。把%s改成%x就能打印出地址值了。

printf("%s/n",a);－与上面一样，打印出地址里面的内容，从这也可以看出，数组名已经退化为指针了，但数组与指针有着本质的不同。

printf("%c/n",*p); －输出字符串中的第一个字符，由于p指向的是字符数组的首地址，自然*p就输出字符数组的首字符了。

printf("%s/n",(p+1)); －p指向数组的首地址，那么p+1指向的是数组的第二个元素的地址，即a[1]的地址，那么p+1打印了是从第二个字符一直到/0为止的所有字符。即bcde.

p=&a[1]; －这条语句也是很有讲究的。等式左边是一个char型指针变量，那么等式右边也应该是char型指针变量，a[1]是一个字符值，&a[1]就是a[1]的地址，即是一个字符指针。

printf("%s/n",p); －由于p指向a[1]的地址，那么输出的应该是bcde.

printf("%c/n",*p+10); －*p的值是b, b+10也是一个字符，由于字符与整数是相对应的，所以b+10为字符l.

printf("%x/n",a); －打印出数组a的首地址.

printf("%x/n",&a); －也是数组的首地址。但我们多次强调，a与&a的类型是不一样的。

printf("*a=%c/n",*a);－打印出数组的第一个元素，即a.

printf("%s/n",a+1); －打印出bcde.

for(i=0;i<4;i++){
printf("11%c/n",*(p+i));
}

p指向地址a[1],那么打印出的应该为bcde. *(p+i)=a[i].

小结

一维数组与指针的关系始终要注意三点:

（1）当数组名出现在表达式中，此时数组已经退化为指针了。

(2) 在输出数组名或者指针指向的数组地址时，其输出的是内容值，直到/0结束为止。

(3) *(p+i)=a[i] , a与&a类型是不一样的，前者是char型指针，后者是char(*)[5]数组指针类型。

另外在传参数的时候，char* strcpy(char* s1, const char* s2);－第一个参数直接可以传入字符数组名，因为字符数组名已经退化为指针了。

因此，可以这样认为，C语言中没有真正意义上的数组，只在定义层面上，它是一个数组，而在应用的时候都退化为指针了。

二.二维数组与指针的关系

前面分析了一维数组与指针的关系，二维数组与指针的关系较为复杂。

首先，我们认清两个概念，指针数组与数组指针。

指针数组：指针数组是一种特殊的数组，这类数组里面存放的全是指针。

如const char*c[4]={""China","USA","Rassia",""Japan"};

这是一个指针数组，里面包含4个指针分别是c[0],c[1],c[2],c[3].这四个指针分别指向字符串的首地址。

数组指针: 数组指针是指向一个数组的指针。如 char(*c)[4]([]的优先级比*高，因此要有括号). 定义了一个指向长度为4的数组的指针。

指针数组本质上是数组，数组指针本质上是指针。

同样，我们看一段程序:

#include <stdio.h>

#include <string.h>

#include <stdlib.h>

int main(int argc,char*argv[]){

char a[2][6]={"abcde","ABCDE"};

char *p;

char (*p1)[6];

printf("%x/n",a); //输出bfd2fc08

printf("%x/n",&a); //bfd2fc08

printf("%x/n",*a); //bfd2fc08

printf("a[0]=%x/n",a[0]); //bfd2fc08

printf("a[1]=%x/n",a[1]); //bfd2fc0e

printf("a[0]+1=%x/n",a[0]+1); //bfd2fc09

printf("*(a[0]+1)=%c/n",*(a[0]+1)); //b

printf("&a[0]=%x/n",&a[0]); //bfd2fc08

printf("%s/n",&a[0]); //abcde

printf("&a[0][0]=%x/n",&a[0][0]);//bfd2fc08

printf("%s/n",&a[0][0]+1); // bcde

printf("&a[0]+1=%x/n",&a[0]+1); //bfd2fc08

printf("%s/n",&a[0]+1); //ABCDE

printf("%s/n",a); //abcde

printf("%s/n",a+1); //ABCDE

printf("%s/n",*a+1); //bcde

printf("%s/n",*(a+1)); //ABCDE

printf("%c/n",**(a+1)); //A

printf("%c/n",*(*(a+1)+1)); //B

p1=a;

p1=&a[0];

printf("p1=%s/n",p1); //abcde

printf("p1+1=%s/n",p1+1); //ABCDE

printf("%x/n",p1); //bfd2fc08

printf("%x/n",p1+1); //bfd2fc0e

printf("%x/n",*p1); //bfd2fc08

printf("%x/n",*(p1+1)); //bfd2fc0e

printf("%c/n",**(p1+1)); //A

printf("%c/n",*p1[0]); //a

printf("%c/n",*(p1[0]+1)); //b

int j;

p=a[0];

p=&a[0][0];

for(j=0;j<11;j++){

printf("%c/n",*(p+j));

}

//输出 abcde ABCDE

char *v[]={"hello",""world"};

int k;

for(k=0;k<2;k++){

printf("%s/n",v[k]);

printf("%s/n",*(v+k));

printf("%c/n",*v[k]);

printf("%c/n",**(v+k));

}

//输出hello hello h h world world w w

return 0;

}

估计看到这，肯定有点迷糊。下面一行一行解释上面的程序:

char a[2][6]={"abcde","ABCDE"}; －定义了一个二维字符数组

char *p; －定义了字符指针变量

char (*p1)[6]; －定义了数组指针，一个指向数组长度为6的数组指针p1,里面存放的是数组的首地址

printf("%x/n",a);
printf("%x/n",&a);
printf("%x/n",*a);

先不着急，看它们的输出内容，分析一下它们的数据类型。a是一个二维数组名，它指向的是二维数组的首地址。那么a的类型应该是char(*)[6]即一个指向二维数组中每一维数组的数组指针。这一点，不好理解，其实二维数组可以看成是数组的数组，那么a就指向了二维数组中的内层数组，在上面的程序中，二维数组a包含两个一维数组，那么a就是指向了第一个一维数组的数组指针。因此，它是一个数组指针类型。

&a是数组名a的地址，它是一个指向二维数组的指针，所以它的类型是 char(*)[2][6],是指向整个二维数组的二维数组指针。

*a相当于a[0],即指向二维数组中第一个数组的char型指针变量。由于二维数组可以看成是数组的数组，那么二维数组中的a[0]就相当于一维数组中的数组名，所以它是一个char型指针变量。

所以，数组名a的类型是char(*)[6]的数组指针，&a是char(*)[2][6]二维数组指针，*a是一个char型指针变量。它们的类型有着本质的不同。这是理解二维数组的精华所在。强调一句，二维数组与一维数组一样，在表达式中，退化为指针类型，不过不是简单的指针类型，也不是二重指针，它与二重指针有着本质的区别。

上述三条语名的输出值是一样的，即二维数组的首地址值。

printf("a[0]=%x/n",a[0]); //a[0]是一个地址值，即二维数组中第一维数组的首地址。其值与a相同，类型不同，a[0]退化为char型指针。

printf("a[1]=%x/n",a[1]); //a[1]的值是二维数组中第二维数组的首地址，类型与a[0]相同。

printf("a[0]+1=%x/n",a[0]+1); //a[0]是一维数组的首地址，那么a[0]+1当前是a[0][1]的地址了。

printf("*(a[0]+1)=%c/n",*(a[0]+1));//a[0]+1是a[0][1]的地址，那么*(a[0]+1)就是a[0][1]的内容了。

printf("&a[0]=%x/n",&a[0]); //与a一样，数组的首地址值，a[0]是一个char*型指针，&a[0]就是一个char(*)[6]指向一维数组的数组指针与a的s类型相同了。

printf("%s/n",&a[0]); //&a[0]与a一样，指向的是二维数组中第一维维的首地址，前面说过，一遇到地址输出内容，直到/0为止，所以输出的应该为 abcde.

printf("&a[0][0]=%x/n",&a[0][0]); //输出的是a[0][0]的地址，&a[0][0]与a[0]的类型相同，是一个char型指针。

printf("%s/n",&a[0][0]+1); //&a[0][0]相当于a[0],a[0]+1从二维数组的第一维数组中的第2个字符一直输出到/0，即bcde

printf("&a[0]+1=%x/n",&a[0]+1); //&a[0]相当于a，是一个字符指针数组类型，a+1输出的是二维数组中的第二个一维数组的元素值，直到/0为止。

printf("%s/n",a); //输出二维数组中的第一个数组，直到/0为止。即abcde

printf("%s/n",a+1); //输出二维数组中的第二个数组，直到/0为止，即ABCDE

printf("%s/n",*a+1); //*a相当于a[0],a[0]+1,从二维数组中的第一个数组中的第二个字符一直输出到最后，即bcde.

printf("%c/n",**(a+1)); //a+1是第二个数组的地址，*(a+1)为a[1]，即为字符指针，所以**(a+1)，应该为第二个数组的首字符，即A。

printf("%c/n",*(*(a+1)+1)); //a+1的类型为数组指针

p1=a;//等号左边是数组指针类型，即为char(*)[6], a也是一个数组指针。所以类型匹配。

p1=&a[0]; //a[0]是一个指针变量，&a[0]是一个数组指针，相当于a.

printf("p1=%s/n",p1); //输出第一个数组的字符值，直到遇到/0

printf("p1+1=%s/n",p1+1); //p1+1相当于a+1,输出第二个数组的字符，直到遇到/0

printf("%x/n",p1);

printf("%x/n",p1+1);

前一个输出第一个数组的首地址，后一个输出第二个数组的首地址。

printf("%x/n",*p1); //*p1相当于a[0]，是一个字符指针，a[0]的首地址。
printf("%x/n",*(p1+1)); //*(p1+1)相当于a[1],即a[1]的首地址
printf("%c/n",**(p1+1)); //**(p1+1)即a[1][0]的值
printf("%c/n",*p1[0]); //[]的优先级比*高，p1[0]代表a[0]的首地址，*p1[0]为第一个数组的第一个字符。
printf("%c/n",*(p1[0]+1)); //第一个数组的第二个字符

char *v[]={"hello",""world"};

int k;

for(k=0;k<2;k++){

printf("%s/n",v[k]);

printf("%s/n",*(v+k));

printf("%c/n",*v[k]);

printf("%c/n",**(v+k));

这段代码是一个指针数组类型， v[k]是一个地址，一遇到地址输出字符值，直到/0结束。

*(v+k) 相当于v[k]. (为了好理解，可以把v看成是二维数组中的a,那么a+k类型是数组指针类型，*(v+k)就是字符指针类型，所以是值是个地址)

*v[k]第一个字符。

**(v+k)同上。

小结: 要深刻理解二维数组退化为指针这一概念。二维数组与数组指针的关系。