数组指针和指针数组

1.数组名

数组首元素的地址和数组地址是两个不同的概念

• 数组名代表数组首元素的地址，它是个常量.

• 变量本质是内存空间的别名，一定义数组，就分配内存，内存就固定了。所以数组名起名以后不能被修改了。

• 数组首元素的地址和数组的地址值相等。

1.1怎么样得到整个一位数组的地址？

int a[10];
printf("得到整个数组的地址a:%d\n",&a);
printf("数组的首元素的地址a:%d\n,a);

2.数组类型

数组的类型由元素类型和数组大小共同决定

int array[5] 的类型为 int[5]
#include <stdio.h>
/*
typedef int(MYINT5)[5];
typedef float(MYFLOAT10)[10];

数组定义：

MYINT5 iArray;        等价于 int iArray[5];
MYFLOAT10 fArray;     等价于 float fArray[10];

*/
/*定义 数组类型，并用数组类型定义变量*/

int main(void)
{
  typedef int(MYINT)[5];

  int i = 0;

  MYINT array;

  for(i = 0 ; i < 5; i++)
   {
        array[i] = i;
   }
  
   for(i = 0;i < 5;i++)
    {
     printf("%d ",array[i]);
    }
   return 0;
}

3.数组指针和指针数组

3.1指针数组

char   *point_array[4];
(char *)point_array[4];

指针数组，是一个数组，里面的每一个元素都是一个指针。（多个指针）

1.png

3.2数组指针

int (*array_point)[4];

是一个指针，指向一个数组

2.png

指针本是一种类型，但又说什么类型的指针，只不过是说指针所指向的数据是什么类型而已。那么指向数组类型的指针，就只好叫数组指针

3.3定义数组指针

int a[10]; // a的类型是一个指向int类型的指针

数组名a是数组首元素的起始地址，但并不是数组的起始地址。

&a;  //&a的类型是一个指向数组int[10]类型的指针

通过将取地址符&作用域数组名可以得到整个数组的起始地址

1)通过数组类型定义数组指针：
typedef int(ArrayType)[5]; //定义类型ArrayType为int[5]类型

ArrayType* pointer;//那么指向ArrayType的指针就是指向int[5]类型的指针

2) 通过数组指针定义数组指针
typedef int (*MyPointer)[5];   //定义类型MyPointer为指向int[5]类型的指针

MyPointer myPoint;   //那么⽤用这种类型的指针定义的便利都是指向int[5]类型的

3）直接定义
int (*pointer)[5];

3.4数组指针有什么用？

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

void test()
{
  //  int //0维数组，一级指针
 //   int[10] //一维数组，二级指针
 //   int[10][20]//二维数组，三级指针
   int a[3][4];
    //a是一个指针，指向此二维数组首元素(int[4])的地址，int (*p)[4] --->二级指针，指向一维数组
    //&a也是一个指针，指向此二维数组(int[3][4])的地址，int(*p)[3][4] --->三级指针，指向一个二维数组

    //一个数组指针如果是几级指针，就是指向比他低一个维度的数组
}


int main(int argc, char const *argv[])
{
    //定义一个指针数组
    //char *pointer_array[4] = {NULL,NULL,NULL,NULL};//在栈上
    char *pointer_array[4] = {NULL};//数组，一定要记得加大括号
    int i = 0;
    for (i = 0; i < 4; ++i)
    {
        pointer_array[i] = malloc(100);
    }
    
    //定义一个数组指针
    //方法一：
    //通过数组类型定义一个数组指针
    typedef int(ARRAY_CHAR_4)[4];
    ARRAY_CHAR_4 array = {0};//int[4]类型 array是数组首元素的地址
    ARRAY_CHAR_4 *p = NULL; //数组的地址 (int[4]) *p = NULL

    p = &array;//array int *   &array-->(int[4])*

    for (i = 0; i < 4; ++i)
    {
        (*p)[i] = i;//等价于 array[i] = i;
      //  p[i] = i;为int[4] *(p+i)==p[i]
    }

    for (i = 0; i < 4; ++i)
    {
        printf("%d\n",array[i]);
    }
    
    int size = 0;
    size = sizeof(ARRAY_CHAR_4);
    printf("ARRAY_CHAR_4 = %d\n",size);//输出16

    //方法二：
    //数组指针
    typedef int(*ARRAY_CHAR_4_POINTER)[4];//一个int，指向int[4]

    ARRAY_CHAR_4_POINTER array_pointer = &array;
    
    size = sizeof(ARRAY_CHAR_4_POINTER);
    printf("ARRAY_CHAR_4_POINTER = %d\n",size);//输出4

    for (i = 0; i < 4; ++i)
    {
        (*array_pointer)[i] = i;
    }

    for (i = 0; i < 4; ++i)
    {
        printf("%d\n",array[i]);
    }

    //方法三
    int(*array_p)[4] = NULL//直接定义一个数组指针
    array_p = &array;

    for (i = 0; i < 4; ++i)
    {
        (*array_p)[i] = i;
    }
    
    for (i = 0; i < 4; ++i)
    {
        printf("%d\n", array[i]);
    }

    return 0;
}