int a = 10;
int* pa = &a;

char ch = 'w';
char* pc = &ch;

#include<stdio.h>
int main()
{
    int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };
    //int* p = arr;//数组名是首元素地址
    //数组指针 存放数组的指针变量
    int(*p)[10] = &arr;//(*p)代表p是指针变量
    //该指针指向了一个数组，数组10个元素，每个元素的类型是int
    //如果不用括号将*p括起来，写成int* p[10]，这是指针数组
    return 0;
}

#include<stdio.h>
//常见的方式
void print_arr1(int arr[3][5], int x, int y)
{
    int i = 0;
    int j = 0;
    for (i = 0; i < x; i++)
    {
        for (j = 0; j < y; j++)
        {
            printf("%d ", arr[i][j]);
        }
        printf("\n");
    }
}

//数组指针方式
void print_arr2(int(*p)[5], int x, int y)
{
    int i = 0;
    int j = 0;
    for (i = 0; i < x; i++)
    {
        for (j = 0; j < y; j++)
        {
            printf("%d ", (*(p + i))[j]);
            printf("%d ", *(*p + i）+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} };
    //打印这个二维数组
    print_arr1(arr,3,5);//数组名，行，列也要传参
    
    print_arr2(arr, 3, 5); //数组名-首元素地址
    return 0;
}

#include<stdio.h>
int main()
{
    int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };
    int* p = arr;
    int i = 0;
    for (i = 0; i < 10; i++)
    {
        printf("%d ", *(p + i));
        //方式一：通过指针找到与首元素偏移i个元素的地址，
        //再对齐解引用操作，找到这个元素
        printf("%d ", *(arr + i));
        //方式二：既然可以将arr赋值给p，说明arr与p等价
        //那么就可以直接用arr替代p进行相应的解引用操作
        printf("%d ", arr[i]);
        //方式三：通过数组名+[下标]访问数组元素
        //即arr+[下标i]访问下标为i的元素，也就是第i+1个元素
        printf("%d ", p[i]);
        //方式四：既然arr与p等价，
        //那么也可以直接用p+[下标]的方式访问数组的元素

        //上述四种方式实际结果完全相同，实际上也可以互相转换使用
    }
    return 0;
}

int arr[5];
int* parr1[10];
int(*parr2)[10];
int(*parr3[10])[5];

int arr[5];
//arr是一个数组，数组有5个元素，每个元素类型是int
//arr类型是  int [5]  --- 去掉变量名，剩下的就是变量的类型

int* parr1[10];
//parr1是一个数组，数组有10个元素，每个元素类型是int*
//parr1是指针数组,类型是 int* [10]

int(*parr2)[10];
//parr2是一个指针，指针指向一个数组，数组有10个元素，每个元素的类型是int
//parr2是数组指针,类型是 int(*)[10]

int(*parr3[10])[5];
//parr3是一个数组，数组有10个元素，每个元素都是一个指 针
//指针指向一个数组，数组有5个元素，每个元素类型是int
//parr3是一个指向数组指针的数组，本质上还是数组
//parr3类型是 int(*[10])[5]

#include <stdio.h>
void test(int arr[])//ok? 
{}
void test(int arr[10]) //ok?
{}
void test(int* arr)//ok?
{}
void test2(int* arr[20])//ok?
{}
void test2(int** arr) // ok ? 
{}
int main()
{
    int arr[10] = { 0 };
    int* arr2[20] = { 0 };
    test(arr);
    test2(arr2);
}

void test(int arr[3][5])//ok ?
{}
//可以
void test(int arr[][])//ok ?
{}
//不可以，行可以省略，列不可以，第一个[ ]内容可以不写，第二个[ ]要写
void test(int arr[][5])//ok ?
{}
//可以
void test(int* arr)// ok ? 
{}
//不可以
void test(int* arr[5])//ok ?
{}
//不可以
void test(int(*arr)[5])//ok ?
{}
//可以
void test(int** arr)// ok ? 
{}
//不可以
int main()
{
    int arr[3][5] = { 0 };
    test(arr);
}

void test1(int* p)
{
}
int main()
{
    int a = 10;
    int* pa = &a;
    int arr[10] = { 0 };
    test1(&a);
    test1(pa);
    test1(arr);
    return 0;
}

void test2(char* p)
{
}
int main()
{
    char a = 'W';
    char* pa = &a;
    char arr[10] = { 0 };
    test2(&a);
    test2(pa);
    test2(arr);
    return 0;
}

void test(int** p)
{
}
int main()
{
    int* p1;
    int** ptr;
    int* arr[5];
    test(&p1);//一级指针取地址
    test(ptr);//二级指针
    test2(arr);//一级指针数组的首元素
    return 0;
}