数组指针与指针数组

指针类型  

①数组指针—实际是指针

int main()
{
    int* pa = null;   //pa是整型指针 —— 指向整形的指针——可以存放整形的地址
    char* pc = null; //pc是整型指针 —— 指向字符的指针——可以存放整形的地址

    // int arr1[10] = { 0 };
    // arr-首元素地址     arr+1跳过一个元素
    // &arr[0]-首元素地址
    // &arr-数组的地址    &arr+1跳过一个数组

    int arr[10] = { 1,23,4,5,6,7,8,9,10 };

    //错误写法：int*p[10]=&arr; []优先级大于*，此时p是数组而不是指针
    int(*p)[10] = &arr; //p是数组指针 —— 指向数组的指针——可以存放数组的地址   
    //[5]——>指针指向的数组是5个元素的
    return 0;
}

 数组指针的应用场景

//打印二维数组——循环的方法：参数是数组的形式
void print1(int arr[3][5], int x, int y)                           
{                                                            
        int i = 0, j = 0;                                        
        for (i = 0; i < x; i++)//依次进入每一行进行操作           //对于打印一维数组：
        {                                                       //   int* p=arr;
                for(j = 0; j < y; j++)  //打印一行内的所有元素        //   printf("%d",*(p+i));
                {                                                   //   arr[i] = *(arr + i) = *(p + i) = p[i]  
                        printf("%d ", arr[i][j]);
                }
                printf("\n");//打印完一行之后进行换行
        }
}
//打印二维数组——指针的方法——参数是指针的形式
void print2(int(*p)[5], int x, int y)  //用数组指针接收数组（{1，2，3，4，5}这个一维数组）的地址
{
        int i = 0;
        for (i = 0; i < x; i++)//定位二维数组的每一行
        {
                int j = 0;
                for (j = 0; j < y; j++)  //定位二位数组一行中的每个元素
                {
                        printf("%d ", *(*(p +i) + j));
            //p指向一行（一维数组），p+i表示跳过i个一维数组，进入下(i+1)行，*（p+i）解引用拿到了第(i+1)行的数组名
        //*（p+i）+j拿到了一行中下标为j这个元素的地址 , *(*(p +i) + j)解引用得到了具体元素

//另一种写法：printf("%d ", (*(p + i)[j]);
            //p指向一行（一维数组），p+i表示跳过i个一维数组，进入下(i+1)行，*（p+i）解引用拿到了第(i+1)行的数组名
        //(*(p + i)[j]表示第（i+1）行的下标为j的元素        

//另一种写法：printf("%d ", p[i][j]);
//另一种写法：printf("%d ", *(p[i]+j));
        }
        printf("\n");//打印完一行之后进行换行        
        }
}

int main()
{
        int arr[3][5] = { {1,2,3,4,5},{2,3,4,5,6},{3,4,5,6,7} };
        print1(arr,3,5);//arr - 数组名 - 首元素地址 

        print2(arr, 3, 5);
//二维数组的首元素——>把它看出一维数组，则它的首元素{ 1，2，3，4，5 }，所以它的首元素地址为第一行这个一维数组的地址
        return 0;                                                          
}

②指针数组—实际是数组

int main()
{
        int a = 10, b = 20, c = 30, d = 40;
        int* arr[4] = { &a,&b,&b,&d };
        int i= 0;
        for (i = 0; i < 4; i++)
        {
                printf("%d ", *(arr[i]));
        }
        return 0;
}

指针数组的应用场景 

#include<stdio.h>
int main()
{                                                   
        int arr1[] = { 1,2,3,4,5 };                          
        int arr2[] = { 2,3,4,5,6 };
        int arr3[] = { 3,4,5,6,7 };
        int* parr[] = { arr1,arr2,arr3 };
        int i = 0;
        for (i = 0; i < 3; i++)
        {
                parr[i];     //当i=0是，就是arr1首元素的地址 → 定位数组
                int j = 0;
                for (j = 0; j < 5; j++)
                {
                        printf("%d ",*(parr[i] + j));//当i=0，j=1是，就是arr1中的第二个元素 → 定位元素
                }
                printf("\n");   //打印完第一个数组之后，进行换行
        }
        return 0;
}

总结： 

[ ]的优先级比*高，在一般情况下，arr先与[ ]结合

int arr[5];     

 //arr是一个5个元素的整型数组

int* parr1[10];   

//parr1是一个数组，该数组有10个元素，每个元素的类型是int*，parr1是指针数组

int(*parr2)[10];  

//parr2是一个指针，该指针指向了一个数组，数组有10个元素，每个元素的类型是int，parr2是数组指针

int(*parr3[10])[5];

//parr3是一个数组，该数组有10个元素，每个元素是一个数组指针，数组指针指向5个元素，每个元素是int