与指针初识

一维数组：

int a[10];

int *p=&a[0]           p=&a[0]          *p=a[0]

---

p+1->&a[0]+1         //指针加1在数值上表示加了1个指向类型的长度sizeof(int)

p+1->&a[0]+1->&a[1]                  以此类推

p+2->&a[0]+2->&a[2]

.......................................

p+i->&a[0]+i->&a[i]

在一个数组中，如果定义了一个指针保存a[0]的地址，则有式子 p+i->&a[0]+i->&a[i]

*(p+i)->*(&a[0]+i)->*(&a[i])->a[i]

---

1、在以上条件的基础上，假如要把100的值赋给a[0]，请问有几种方法？

a[0]=100  <->  *(&a[0])=100  <->  *p=100  <->  *a=100  <->  *(p+0)=100  <->  p[0]=100

2、假如int a[10]，int *p=&a[2]，请问p[2]表示：

p->&a[2]  -->  p[2]  <->  *(&p[2])  <->  *(&p[0]+2)  <->  *(p+2)  <->  *(&a[2]+2)  <->  *(&a[4])

a[2]  <->  *(&a[2])  <->  *(&a[0]+2)  <->  *(a+2)  <->  a[2]

---

int a[10]        int *p=a  <->  int *p=&a[0]  ==>  p=a  ==>  p=&a[0]

数组名可以代表数组的首元素地址  a  <->  &a[0]

sizeof(a)：求整个数组的大小

typeof(a)：求这个数组的类型

typeof(p)  <->  typeof(&a[0])  <->  typeof(a[0])*  <->  int  *  ===>   typeof(&x)  <->  typeof(x)*

p=a：都是保存了a[0]的地址

a+1：&a[0]+1==>&a[1]     //这个时候把数组名当做指针来用

*(a+1)：*(&a[0]+1)==>*(&a[1])==>a[1]           //这个时候把数组名当做指针来用

---

int a[10]={1,2,3,4,5,6,7,8,9,10}       

int a[10] <==>  int[10]  a  <==>  typeof(a) ==> int [10]

a：&a[0]

a+1：&a[0]+1  <==>  &a[1]

&a+1：a是数组，&a表示的是数组的指针，指针做加减，要观察指针的类型===>&a                        typeof(&a)  ==>  typeof(a)*  ==>  (int [10])*  ==>  表示每次指针加减都是在10个int类型的基础上进行！       &a+1  ==>  加10个int大小的字节

&a[0]+1：typeof(&a[0])  ==>  typeof(a[0])*  ==>  int *  ==>指针每次加减是在一个int字节的基础上

注意：  

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

&a[0]：取数组的第一个元素的地址

&a：取整个数组的地址，这是一个指向数组的地址

typeof(&a)  <==>  typeof(a)*  <==>  (int[10])*：指针每次加减是在10个int大小字节的基础上进行

typeof(&a[0])  <==>  typeof(a[0])*  <==>  int*：指针每次加减都是在1个int大小字节的基础上进行

---

二维数组：

int b[2][3]={1,2,3,4,5,6}           

二维数组本质是一个一维数组：int b[2][3] ==>(int[3]) b[2]

b：数组名做数组首元素地址 ==> &b[0]

&b：这里把b看做整个数组

&b+1：指针做加减看类型==>  typeof(&b)  ==>  typeof(b)*  ==>  (int[2][3])* ：指针加减都是在一整个二维数组大小的字节数的基础上  

b+1：&b[0]+1  指针加减看类型：typeof(&b[0]) ==> typeof(b[0])*  ==>int[3]*    指针每次加减在一个3个int大小的字节的基础上            b+1 ==>  &b[0]+1 ==> &b[1]

&b[0]+1：typeof(&b[0]) ==>  typeof(b[0])*  ==>  (int[3])*      &b[0]+1==>&b[1]

---

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

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

分析：typeof(&a)==>typeof(a)*==>(int[5])*：指针每次加减都是加减整个数组5个int字节大小          强制类型转换成(int*)，变成指针每次加减一个int字节大小       

*(a+1)：*(&a[0]+1)  指针加减看类型，typeof(&a[0])=typeof(a[0])*=int*：指针每次加减一个int字节大小，所以*(&a[0]+1）=*(&a[1])=a[1]

*(ptr-1)：ptr本来是(&a+1)，数组的首地址往后移动了5个int字节大小，强制转换成int*类型，指针每次加减1个int字节大小，ptr-1往前移动一个int字节，所以是a[4]=5；

---

在上面二维数组的基础上，要定义一个指针变量p，保存数组的第一个数值b[0][0]的地址，该如何定义呢？

typeof(b[0][0])=int*   ==>   所以可以这样定义p ===>int *p=&b[0][0]

二维数组名b代表的意思有：&b[0]，如果要用指针p保存这个地址的话，应该怎么去写呢？

typeof(b[0]) == (int[3])*  ===> 所以可以这样定义p的类型 ===> (int[3])* p=&b[0]=b ===> 因为类型和数字不能连在一起===>int (*p) [3]=&b[0]=b ==>这样也叫数组指针 

---

数组指针：

数组指针归根结底是指针，指向一个数组，用来保存数组的地址；

像上面部分写的那样，int (*p) [3]=&b[0]=b，

指针数组：

指针数组是一个数组，数组里面的每个元素是指针；

int* p[3]：定义一个数组p，里面有3个int*，3个int类型的指针；

区别：

数组指针：int (*p)[3]

指针数组：int *p[3]

注意：要避免访问未初始化的指针！

---

这是我在学C语言中，通过老师讲解和询问同学对自己的学习的一个总结，文中有不对或说法不准确的地方，恳请各位大佬指正！

本人的评论区欢迎大家讨论技术性的问题！