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

一维数组和指针之间的关系
==============================
   1.前人总结的经典结论
        结论一：数组名出现在表达式中代表该数组首元素的地址
                数组名相当于是个指针，一个指向本数组首元素地址的指针
        结论二：
            数组名前面&,表示的是指向整个数组的一个指针(数组指针)

   2.int类型一维数组和指针的关系
         int a[10]={45,89,96,12};
        (1)访问数组的方法
             第一种：数组名[下标]
                     a[1];
             第二种: *(数组名+1)
                     *(a+1);
             第三种：引入单独的指针，指向数组的首元素
                     int *p=a; //a等价于&a[0]
                     p[0]; //等价于a[0]第一个元素
                     p[1]; //等价于a[1]第二个元素
                     *(p+2); //等价于a[2]第三个元素
                     for(i=0; i<10; i++)
                          printf("%d\n",p[i]);
                          printf("%d\n",*(p+i));
                          printf("%d\n",*(a+i));
                          printf("%d\n",a[i]);
         (2)两个指针相减
               表示数组中两个指针之间间隔了多少个数据
               注意：经典错误理解成直接用地址值做减法
               总结成公式： (地址-地址)/类型大小
         (3)关于一维数组名的几种写法(重点理解每种写法的含义)
               a      int *类型的指针
               &a     数组指针  
               a[0]   非指针，数组首元素值
               &a[0]  数组首元素的地址
               a+1    加类型的大小  4个字节
               &a+1   加的是整个数组的大小
               a[0]+1 把a[0]的值加1
               &a[0]+1加类型的大小  4个字节

   3.char类型一维数组和指针的关系
         char a[10]="hello";
        (1)访问数组的方法
             第一种：数组名[下标]
                     a[1];
             第二种: *(数组名+1)
                     *(a+1);
             第三种：引入单独的指针，指向数组的首元素
                     char *p=a; //a等价于&a[0]
                     p[0]; //等价于a[0]第一个元素
                     p[1]; //等价于a[1]第二个元素
                     *(p+2); //等价于a[2]第三个元素
                     for(i=0; i<10; i++)
                          printf("%c\n",p[i]);
                          printf("%c\n",*(p+i));
                          printf("%c\n",*(a+i));
                          printf("%c\n",a[i]);
         (2)两个指针相减
               表示数组中两个指针之间间隔了多少个数据
               注意：经典错误理解成直接用地址值做减法
         (3)关于一维数组名的几种写法(重点理解每种写法的含义)
               a      char *类型的指针
               &a     数组指针  
               a[0]   非指针，数组首元素值
               &a[0]  数组首元素的地址
               a+1    加类型的大小  1个字节
               &a+1   加的是整个数组的大小
               a[0]+1 把a[0]的值加1
               &a[0]+1加类型的大小  1个字节

数组指针和指针数组
==============================
   1.数组指针(中心词是指针)
      (1)概念
            指向某个数组的指针
            类型 (*指针名)[数组元素个数]
      (2)如何定义数组指针
            int a[10];
            char b[15];
            int c[10];
            int (*p)[10]=&a;    //定义了 int[10]类型的数组指针，指向a
            p=&c;               //移情别恋，指向c
            char (*q)[15]=&b;   //定义了 char[15]类型的数组指针，指向b

   2.指针数组(中心词是数组)
       (1)概念
             数组中存放的全部都是指针，这种数组就叫做指针数组
             int a[10];  //10个int
             char b[5];  //5个char
             int *c[3];  //3个int *
             char *d[4]; //4个char *
       (2)如何定义指针数组
              指针类型  数组名[数组元素个数];

二维数组和指针之间的关系(比一维数组要复杂)
==============================
   1.前人总结的经典结论
        结论一：二维数组名出现在表达式中代表该数组首元素的地址
                二维数组名相当于是个指针，一个指向本数组首元素地址的指针
                思维要切换(转弯)
                把二维数组理解为特殊的一维数组
                     比如：char a[3][20];  //理解为包含了3个 char[20]的数组
                           int  b[7][15];  //理解为包含了7个 int[15]的数组
        结论二：
            二维数组名前面&,表示的是指向整个数组的一个指针(数组指针)

   2.int类型二维数组和指针的关系
         int a[7][10]={45,89,96,12};
        (1)访问数组的方法
             第一种：数组名[下标][下标]
                     a[i][j];
             第二种: 用数组名来表示
                     *(*(a+i)+j) --》等价替换成 *(a[i]+j)
             第三种：引入单独的指针，指向数组的首元素
                     方法1：通过int *   
                     方法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个字节
   3.char类型二维数组和指针的关系
         char a[3][10]={"hello","china","gec"};
         (1)访问数组的方法
             第一种：数组名[下标][下标]
                     a[i][j];
             第二种: 数组名当成指针
                     *(*(a+i)+j)
             第三种：引入单独的指针，指向数组的首元素
                     
         (2)两个指针相减
               表示数组中两个指针之间间隔了多少个数据
               注意：经典错误理解成直接用地址值做减法
         (3)关于有二维数组名的几种写法(重点理解每种写法的含义)
               a          二维数组首元素的地址 --》  a[0]的地址,数组指针  char(*p)[10]
               &a         数组指针    char (*p)[3][10]  
               a[0]       第一个一维数组char[10]的名字，表示该数组首元素a[0][0]的地址  char *
               &a[0]      数组指针    char (*p)[10]
               a[0][0]    非指针
               &a[0][0]   char *
               a+1        加类型的大小  char[10]大小
               &a+1       加的是整个数组的大小,char[3][10]大小
               a[0]+1     1个字节
               &a[0]+1    加类型的大小  char[10]大小
               a[0][0]+1  把数据加1
               &a[0][0]+1 1个字节