数组指针（指针）
定义：int (*p)[5];
() 的优先级高，首先说明P是一个指针，指向一个整型的一维数组，这个数组有5个元素。
p＋1 ➡️ 20（4 x 5）个字节

用数组指针指向二维数组（int a［4］［3］）

p ＝ a；

include <stdio.h>

int main()
{
int a[3][2] = {{1,2},
{3,4},
{5,6}};
//a[0],a[1],a[2]
//a[0][0]

//指向的是含有2个元素的一维数组
int (*p1)[2] = a;
int (*p2)[2] = a[0];
int (*p3)[2] = &a[0][0];
printf("a1p = %p\n", a);
printf("a2p = %p\n", a[0]);
printf("a3p = %p\n", &a[0][0]);

printf("p1  = 0x%lx\n", p1);

printf("p1 + 1 = %p\n", p1+1);
printf("p2 + 1 = %p\n", p2+1);
printf("p3 + 1 = %p\n", p3+1);

//*p1取出来a的第0个元素的第0个元素的地址
printf("*p1 = %p\n", *p1);
printf("*p2 = %p\n", *p2);
printf("*p3 = %p\n", *p3);

printf("*(p1 + 1) = %p\n", *(p1+1));
printf("*(p2 + 1) = %p\n", *(p2+1));
printf("*(p3 + 1) = %p\n", *(p3+1));


printf("*(*(p1 + 1)) = %d\n", *(*(p1+1)));
printf("*(*(p2 + 1)) = %d\n", *(*(p2+1)));
printf("*(*(p3 + 1)) = %d\n", *(*(p3+1)));

//整数向地址看齐
printf("*(*(p1 + 1) + 1) = %d\n", *(*(p1+1)+1));
printf("*(*(p2 + 1) + 1) = %d\n", *(*(p2+1)+1));
printf("*(*(p3 + 1) + 1) = %d\n", *(*(p3+1)+1));

return 0;

}

指针数组（数组）
定义int＊p［n］
［］的优先级高。与P组合成为数组，再有int＊说明这是一个整形指针数组，他有N个元素，每一个元素是一个整形指针。

除了初始化，数组不能赋值

include <stdio.h>

int main()
{
int* arr[3] = {0};

int a[3][2] = {{1,2},
               {3,4},
               {5,6}};

for (int loop = 0; loop < 3; loop++)
{
    arr[loop] = a[loop];
}

printf("a[0] = %p\n", a[0]);
printf("a[1] = %p\n", a[1]);
printf("a[2] = %p\n", a[2]);


printf("arr[0] = %p\n", arr[0]);
printf("arr[1] = %p\n", arr[1]);
printf("arr[2] = %p\n", arr[2]);


printf("*(arr[0]) = %d\n", *(arr[0]));
printf("*(arr[1]) = %d\n", *(arr[1]));
printf("*(arr[2]) = %d\n", *(arr[2]));

printf("*(arr[0]+1) = %d\n", *(arr[0]+1));
printf("*(arr[1]+1) = %d\n", *(arr[1]+1));
printf("*(arr[2]+1) = %d\n", *(arr[2]+1));

return 0;

}

strtok
strtok(p,””)
分割字符串，以第二个参数
while（1）
｛
p ＝ strtok（p，“”）；
if（p == NULL）
{
break;
}
pnum[i] = p;
i++;
p = NULL;

｝

指针函数
［注意］是函数，只不过返回的类型是指针类型。

include <stdio.h>

include <stdlib.h>

include <string.h>

int* mySum(int a, int b);
int main ()
{
int a = 0;
int b = 0;
int* ret = 0;
scanf("%d%d",&a,&b);

ret = mySum(a,b);

printf("ret = %d\n",*ret);

free(ret);
return 0;

}

int* mySum(int x, int y)
{
/错误
int p = NULL;
*p = x + y
*/
//return &(x + y);／／错误

/*结果可以，但是不要这么来
 返回的空间时栈空间，当这个函数结束后，堆栈空间没有控制权，不要再函数中返回栈空间到主函数。
int num = 0;
num = x + y;
int* p  = #
return p;
*///内存在栈上建立的，归还的时候不能有任何操作

//动态分配内存,malloc返回值是void＊型的，赋值时可以自己强制转换
//malloc开辟的空间在堆上，我们对堆区空间有控制权。
//malloc开辟的空间需要手工释放，如果不释放，内存将被浪费，没有被释放的空间将无法再继续使用。
//一个malloc对应一个free
int* p = (int*)malloc(4);
*p = x + y;
return p;

}

malloc 对应 free

函数指针
顾名思义，函数指针是一个指针，但是这个指针指向的是一个函数，不是普通的数据类型。
int (*p)(int a, int b)
int 表示的是指针所指向函数的返回值类型
p 表示的是指针变量名
（）表示的是指针所指向函数的参数列表

include <stdio.h>

int myMax(int x, int y);
int myMin(int x, int y);//函数原型
int (*p)(int x, int y);
int main()
{
int ret = 0;
p=myMax;

ret = (*p)(6,7);
printf("ret = %d\n",ret);
return 0;

}

int myMax(int x, int y)
{
return((x >=y)? x : y);
}
int myMin(int x, int y)
{
return((x <= y) ? x : y);
}