一、一维数组和指针之间的关系

1.两个重要的结论

结论一：数组名出现在表达式中代表该数组首元素的地址

数组名相当于是个指针，一个指向本数组首元素地址的指针

结论二：

数组名前面&,表示的是指向整个一维数组的一个指针(数组指针)

2.一维数组和指针的关系

2.1 访问数组的方法

第一种：数组名[下标]

a[1];

第二种: *(数组名+1)

*(a+1);

第三种：引入单独的指针，指向数组的首元素

int p=a; //a等价于&a[0]

p[0]; //等价于a[0]

p[1]; //等价于a[1]

*(p+2); //等价于a[2]

2.2 两个指针相减

表示数组中两个指针之间间隔了多少个数据

int a[10]={45,89,96,12};

int *p1=a;

int *p2=&a[7];

p2-p1结果是多少？

注意：经典错误理解成直接用地址值做减法

2.3 关于一维数组名的几种写法

a int *类型的指针

&a 数组指针

a[0] 非指针，数组首元素值

&a[0] 数组首元素的地址

a+1 加类型的大小 4个字节

&a+1 加的是整个数组的大小

a[0]+1 a[0]的值加1

&a[0]+1 加类型的大小 4个字节

二、数组指针和指针数组

1.数组指针(中心词是指针)

1.1 概念

int *p; int类型指针

char *p; char类型指针

数组 *p；数组类型指针 --》数组指针 --》指向某个数组的指针

类型 (*指针名)[数组元素个数]

1.2 如何定义数组指针

int a[10];

char b[15];

int (*p)[10]=&a; //定义了 int[10]类型的数组指针，指向数组a

char (*q)[15]=&b; //定义了 char[15]类型的数组指针，指向数组b

2.指针数组(中心词是数组)

2.1 概念

数组中存放的全部都是指针，这种数组就叫做指针数组

类型 数组名[元素个数]

情况1：类型是指针 --》这种数组叫做指针数组

int *buf[10];

情况2：类型非指针 --》这种数组就是我们前面学习过的普通类型的数组

int buf[10];

int a[10]; //10个int

char b[5]; //5个char

int *c[3]; //3个int *

char *d[4]; //4个char *

2.2 如何定义指针数组

指针类型 数组名[数组元素个数];

三、二维数组和指针之间的关系

1.两个重要的结论

结论一：二维数组名出现在表达式中代表该数组首元素的地址

二维数组名相当于是个指针，一个指向本数组首元素地址的指针

把二维数组理解为特殊的一维数组

比如：char a[3][20]; //理解为包含了3个 char[20]的数组

int b[7][15]; //理解为包含了7个 int[15]的数组

结论二：

二维数组名前面&,表示的是指向整个二维数组的一个指针(数组指针)

2.二维数组和指针的关系

2.1 访问数组的方法

第一种：数组名[下标][下标]

a[i][j];

第二种：引入单独的指针，指向数组的首元素

2.2 两个指针相减

表示数组中两个指针之间间隔了多少个数据

注意：经典错误理解成直接用地址值做减法

2.3 关于有二维数组名的几种写法

a 二维数组首元素的地址 --》 a[0]的地址,数组指针 int (*p)[10]

&a 数组指针 int (*p)[7][10]

a[0] 第一个一维数组int[10]的名字，表示该数组首元素a[0][0]的地址 int *

&a[0] 数组指针 int (*p)[10]

a[0][0] 非指针

&a[0][0] int *

a+1 加类型的大小 int[10]大小

&a+1 加的是整个数组的大小,int[7][10]大小

a[0]+1 4个字节

&a[0]+1 加类型的大小 int[10]大小

a[0][0]+1 把数据加1

&a[0][0]+1 4个字节

指针的类型决定了加减1的步长

我的理解：

练习题

1.计算结果

#include

int main()

{

int x[]={10,20,30};

int *px=x;

printf("%d",++*px);

printf("%d",*px);

px=x;

printf("%d",(*px)++);

printf("%d",*px);

px=x;

printf("%d",*px++);

printf("%d",*px);

px=x;

printf("%d",*++px);

printf("%d",*px);

return 0;

}

2.下面程序的输出是

int main()

{

int a[5]={1,2,3,4,5};

int *ptr=(int *)(&a+1);

printf("%d, %d\n",*(a+1),*(ptr-1))

}

3.下面判断正确的是

A. char *a="china";等价于char *a; *a="china";

B. char str[10]={"china"};等价于char str[10]; str[]={"china"};

C. char *s="china";等价于char *s; s="china";

D. char c[4]="abc",d[4]="abc";等价于char c[4]=d[4]="abc";

C

自己：A的类型不匹配

B的数组名是常量地址不能修改（赋值）

D的数组名是常量地址不能修改（赋值）

4.#include

void main( )

{

int a=99;

int b=99;

char s1[]="Hello World!";

char s2[]="Hello World!";

if(s1==s2 )

printf(“Equal!”);

else

printf(“Not equal!”);

}

Not equal!

5.#include

void main( )

{

char s[]="Hello World!";

char* p = s;

int n=10;

printf("%d %d %d %d\n",sizeof(s),sizeof(p),strlen(p),sizeof(n));

}

13 8 12 4

注意打印类型：sizeof和strlen否用%zu打印！

6.char buf[10]="gecchina";

char *p=&buf[3];

p=p+2;

*p='#';

printf("buf is:%s\n",buf);

printf("p is:%s\n",p);

gecch#na

#na

7.char buf[5][10]={"hello","world","china"};

char *p=&buf[1][3];

char *q=&buf[2][1];

printf("q-p is:%d\n",q-p);