【深入理解指针】指针的进阶

数组指针 主语：是指针！

我们知道int*是指向int型的指针，char*是指向char型的指针

所以数组指针是指向数组的指针！

p1, p2分别是什么?

int *p1[10];

int (*p2)[10];

p1上面我们讲过是指针数组

而p2就是我们的数组指针了！

为什么呢？

int (*p)[10]; //解释：p先和*结合，说明p是一个指针变量，然后指向的是一个大小为10个整型的数组。所以p是一个 指针，指向一个数组，叫数组指针。
//这里要注意：[]的优先级要高于*号的，所以必须加上（）来保证p先和*结合。

写出下面的数组指针

我们知道定义一个指针是要根据它的类型，然后在类型后面+*就可以定义一个指针了，比如int *a，所以说我们在定义数组指针的时候也要知道数组的类型，那么数组的类型是什么呢？

举个例子，int a=0；去掉变量名后就是它的类型，比如a的类型就是int，所以数组也是同样的方式，int a[5]，去掉变量名后

就是int [5],这个就是它的类型吗？

是的，别怀疑，这个就是它是类型，然后呢，我们就像普通类型一样在加个*和指针名就可以

只不过它的指针名跟int那些不一样，数组指针的名字是放在int 和[]之间的，而且必须要用括号括起来，不然就变成这样了

int *pa [5],它是一个指针数组，因为[]优先级高与*，所以呢数组a的指针最终的结果就是int (*pa)[5],b的也是同样的分析方法。

那数组指针怎么用呢？它有什么作用呢？

我给大家写一个数组指针错误的使用方式！

#include <stdio.h>
int main()
{
    int arr[10] = { 1,2,3,4,5,6,7,8,9,0 };
    int(*p)[10] = &arr;//把数组arr的地址赋值给数组指针变量p

    //但是我们一般很少这样写代码 一个数组指针的比较笨的使用方法
    int i = 0;
    for (i; i < 10; i++)
    {
        printf("%d ", *((*p) + i)  );
    }
    printf("\n");
    //上面的写法我们完全可以用一个整型指针来完成
    int* parr = arr;
    for (i = 0; i < 10; i++)
    {
        printf("%d ", *(parr + i));
    }
    return 0;
}

上面这个列子就是数组指针错误的使用方式，为什么说它错误呢！因为它是的用一个数组指针来实现数组打印，而这个功能完完全全可以用整型指针来实现，可它偏偏用了数组指针，这就将它复杂化，简直就是脱裤子放屁，多此一举！所以我们学数组指针可不是用来实现这样的功能的。

相对正确的使用方式是用于二维数组传参的时候使用的

举个例子

#include <stdio.h>
//以二维数组的形式接受地址
void print_arr1(int arr[3][5], int row, int col)
{
    int i = 0;
    int j = 0;
    for (i = 0; i < row; i++)
    {
        for (j = 0; j < col; j++)
        {
            printf("%d ", arr[i][j]);
        }

    printf("\n");
   }
}
//以数组指针的形式接受地址
void print_arr2(int(*arr)[5], int row, int col)
{
    int j = 0;
    int i = 0;
    for (i = 0; i < row; i++)
    {
        for (j = 0; j < col; j++)
        {
            printf("%d ", arr[i][j]);
        }
        printf("\n");
    }
}
int main()
{
    int arr[3][5] = { 1,2,3,4,5,6,7,8,9,10 };
    print_arr1(arr, 3, 5);
    //数组名arr，表示首元素的地址
    //但是二维数组的首元素是二维数组的第一行
    //所以这里传递的arr，其实相当于第一行的地址，是一维数组的地址
    //可以数组指针来接收
    print_arr2(arr, 3, 5);
    return 0;
}

学了指针数组和数组指针我们来一起回顾并看看下面代码的意思：

int arr[5];
int *parr1[10];
int (*parr2)[10];
int (*parr3[10])[5];
//思考一下上面的代码是表示数组呢，还是数组指针呢？还是其他什么呢？

int arr[5];//一个整型数组，数组有5个元素，每个元素的类型是整型
int *parr1[10];//一个指针数组，数组里有10个元素，每个元素的类型是一个整型指针（int*）
int (*parr2)[10];//数组指针，指向的对象是一个拥有10个元素的数组，每个元素的类型是整型（int）
int (*parr3[10])[5];//一个数组指针数组，数组有10个元素，每个元素的类型是数组指针（int（*）[5]）

第四个再解释一下，因为[]的优先级比*要高，所以parr3先和[]结合，所以它是个数组，又因为我们把parr3[]去掉之后，就剩下了int(*)[5],这不就是数组指针类型吗，其实跟第三个对比一下，parr2去掉之后，就是int(*)[10]，这就是数组指针。所以第四个的类型是数组指针，而它是一个数组，所以最后其实就是一个数组指针数组

#include <stdio.h>
void test()
{
    printf("hehe\n");
}
int main()
{
    printf("%p\n", test);
    printf("%p\n", &test);
    return 0;
}

void test()
{
 printf("hehe\n");
}
//下面pfun1和pfun2哪个有能力存放test函数的地址？
void (*pfun1)();
void *pfun2();

//写出下面函数的函数指针
int add(int x, int y)
{
    return x + y;
}

//代码1
(*(void (*)())0)();
//代码2
void (*signal(int , void(*)(int)))(int);

int *arr[10];//数组的每个元素是int*
int arr1[5];//数组每个元素是int
char* arr[6];//数组每个元素是char*

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

#include<stdio.h>

int add(int x, int y)
{
    return x + y;
}
int sum(int x, int y)
{
    return x - y;
}
int main()
{
    //先写函数指针
    int (*pf)(int, int) = &add;

    //再把函数指针copy过来，在变量名后加个[]
    int (*pf1[5])(int, int) = { &add,&sum };

    printf("pf=%p\npf1[0]=%p\npf1[1]=%p \n", pf, pf1[0], pf1[1]);

    return 0;
}