5.指针的大小

#include <stdio.h>
int main()
{int *p = NULL;//....int a = 10;p = &a;if(p != NULL){*p = 20;}return 0;
}

8.二级指针

（1）二级指针：指向指针的指针（指针变量也是变量，是变量就有地址，指针变量的地址存放在指针里面）

（2）一般定义为：类型名** 变量名

如：int** pa;//int* *pa,pa是一个指针，pa指向的变量是一个int*的变量

（3）二级指针的初始化：

int a = 10;
int* pa = &a;//a的地址存在pa中，pa是一级指针
int** ppa = &pa;//pa的地址存在ppa中，ppa是二级指针

（4）二级指针的操作：

    int a = 10, b = 20, t;int* pa = &a,* pb = &b, pt;int** ppa = &pa, ** pb = &pb, ppt;ppt = ppb; ppb = ppa; ppa = ppt;//①pt = pb; pb = pa; pa = pt;//②t = b; b = a; a = t;//③

部分变量的值变化如表：

解析如下：

9.指针表示法和数组表示法

（1）一维数组

①arr[i]   等价于   *(arr+i)，可以认为*(arr+i)的意思是“到内存的arr位置，然后移动i个单位，检索存储在那里的值”。

②arr + i  等价于  &arr[i]，前面我们说过数组名是数组首元素的地址，所以arr是该数组首元素的地址，首元素的地址+i得到的是第i个元素的地址，即&arr[i]

注意：不要混淆*(arr+2)和*arr+2;前者的意思是arr第2个元素的值，后者的意思是arr第0个元素的值+2

（2）二维数组

假设有定义：int a[3][2];

①a：数组名是数组首元素的地址。我们可以把二维数组a看成是由a[0],a[1],a[2]组成的一维数组，而a[0],a[1],a[2]各自又是一个一维数组。因此数组名a是a[0]（一个内含两个int值的数组）的首元素地址, a[0]是该数组首元素（a[0][0]）的地址。所以我们可以知道两个等价关系：a  等价于  &a[0]； a[0]    等价于   &a[0][0]

②a[0]是该数组首元素（a[0][0]）的地址，所以，*(a[0])等价于a[0][0]的值；与此类似，*a代表该数组首元素（a[0]）的值，而a[0]本身又是一个int类型的地址，所以该值的地址为&a[0][0],换言之，*a就是&a[0][0]。**a等价于*&(a[0][0]),因为*a就是首行首元素的地址，所以再对其进行解引用才能找到首元素的值。我们来捋一下：a即&a[0],  a[0]即&a[0][0], 因此,我们可以得出&a[0] 等价于 &&a[0][0]。其实二维数组名相当于一个二级指针，而a[0]相当于一级指针。注意：二级指针和二维数组名是两码事

③由于a[i]  等价于  *(a+i)，我们也可以得出a[i][j]   等价于  *( *(a+i) + j)或者*(a[i] + j)。

我们来剖析一下 *( *(a+i) + j)这个式子：a是该二维数组首元素的地址（第0行的地址），a+i就是第i行的地址

*(a+i)就是第i行首元素的地址

*(a+i)+j就是第i行，第j列的地址

*(*(a+i)+j)就是第i行，第j个元素

如：*(*(a+2)+1)就是第2行第1列（下标从0开始计数）的元素值，即a[2][1]。

说了这么多，我们上个表格来看看它们之间的等价关系：

二、指针数组和数组指针

1.指针数组

其实C语言中数组可以是任何类型的，如果数组的各个元素都是指针类型，用于存放内存地址，那么这个数组就是指针数组。

（1）一维指针数组定义的一般格式为：类型名* 数组名[数组长度]

如：int* arr[5];//arr是一个数组，有五个元素，每个元素是一个整形指针。该数组的类型是int* []。（去掉变量名就是类型）

（2）指针数组的初始化：

指针数组的各个元素是指针，用于存放地址，因此，我们可以用指针（地址）作为初始化内容，如:

//(1)
int arr[] = {1,2,3};
int* parr[]={arr};//(2)
char* color[5] = {"red", "blue", "yellow", "green", "black"};
//字符串常量实质上是一个指向该字符串首字符的指针常量

（3）指针数组和二级指针

char* color[5] = {"red", "blue", "yellow", "green", "black"};

①数组名是数组首元素(一个指向“red”的字符指针)的地址,所以color其实相当于一个二级指针

②color[1]等价于*(color+1):color+1是数组第1个元素的地址，*(color+1)访问的是数组的第一个元素，它是一个字符指针，指向“blue”的首字符"b"

③*(*(color+2)+4)：同理：*(color+2)访问的是“yellow”的首字符“y”的地址，加4，向后偏移4，找到“o”的地址，再解引用，得到“o”

④(*color+1)[1]:*color实际上访问的是"red"的首字符“r”的地址,加1，向后偏移1，找到"e"的地址，按照[]的访问，向后再偏移1个字符的地址，访问到“d”.这条表达式，它等价于*(*color+1+1)

⑤*color[3]+2:color[3]找到的是第3个元素的地址，*color[3]找到的是第三个元素的首字符“g”，字符"g"+2，实际上是"g"的ASCII码值+2，得到105,105对应的是字符“i”。

2.数组指针

（1）数组指针：可以指向数组的指针

如：int (*p)[10];//p先和*结合，说明p是一个指针变量，然后指针指向的是一个大小为10的数组，该数组的每个元素是一个整型。所以p是一个指针，指向一个数组，叫数组指针，该数组指针的类型为int(*)[10]。

我们可能会疑问：既然数组指针的类型是int (*)[10],数组指针的变量名为p,为什么不写成int (*)[10] p;呢？其实是为了好看方便，所以写成了int (*p)[10];数组指针的一般形式为：类型名 (*指针变量名)[数组长度]。类型名指的是指针指向的数组的元素的类型。

（2）&数组名和数组名

①第一组的+4的解释：arr是数组首元素的地址，因为arr的类型是int*，所以arr+1跳过4个字节

②第二组的+4的解释：&arr[0]是数组首元素的地址，同样的，&arr[0]的类型也是int*，所以&arr[0]+1也是跳过4个字节

③第三组的+40的解释：&arr是数组的地址，它的类型是int(*)[10]，一个指向大小为10的整型数组的指针，所以它+1，应该跳过一个数组的大小10*4=40。

（3）数组指针的使用

数组指针里面存放的是数组的地址。我们来看2个代码：

①

第一个for循环打印出来的是随机值的原因如图，解决方案为第二个for循环，我们可以把这个一位数组看成是二维数组的第一行，这样*(p+0)访问的是一维数组首元素的地址,然后(*(p+0))[i],就可以访问后面的元素了，(*(p+0))[i]等价于p[0][i]。其实，这样传参大可不必，太容易出错了，我们应该这样传参:print_arr(arr);然后用一级指针接收。

②

#include <stdio.h>
void print_arr(int (*arr)[5], int row, int col)
{int i;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_arr(arr, 3, 5);return 0;
}

三、函数指针

1.函数指针定义的一般形式为：(类型名)(*变量名)(参数类型表)

类型名：指定函数的返回类型；变量名：指向函数的指针变量的名称

如：int(*funp)(int,int);//定义了一个函数指针funp，它可以指向有两个整型参数且返回值类型为int的函数，该函数指针的类型为int(*)(int,int),由于和数组指针相同的道理，我们不写成int(*)(int,int) funp;

2.通过函数指针调用函数

（1）在使用函数指针之前，要先对它赋值。赋值时，将一个函数名赋给函数指针，但是该函数必须已经定义或声明，且函数返回值的类型要和函数指针的类型一样。（函数名和&函数名意义相同，都代表函数的地址）（函数指针用来存放函数的地址）

（2）函数调用的一般格式：

(*函数指针名)(参数表)

如：假设fun(x, y)已经有定义，现在要调用fun函数

int(*funp)(int,int) = fun;fun = (3,5);
(*funp)(3,5);
//两者完全等价

3.函数指针作为函数参数：

C语言的调用中，函数名或已赋值的函数指针也能作为实参，此时，形参就是函数指针，它指向实参所代表函数的入口地址,如：

int Add(int x,int y)
{return x + y;
}
int main()
{int (*pf)(int, int) = Add;int ret;ret = (*pf)(4, 5);printf("%d\n", ret);return 0;
}

编译运行该代码，输出如下：

9

#include <stdio.h>
int Add(int x, int y)
{return x + y;
}
int Sub(int x, int y)
{return x - y;
}
...
int main()
{//int (*pf)(int, int) = Add;//int (*pf)(int, int) = Sub;int (*pfArr[2])(int, int) = { Add,Sub };//初始化...return 0;
}

五、指向函数指针数组的指针

六、回调函数

1.回调函数：一个通过函数指针调用的函数。如果你把函数的指针（地址）作为参数传递给另一个函数，当这个指针被用来调用其所指向的函数时，我们就说这是回调函数。回调函数不是由该函数的实现方直接调用，而是在特定的事件或条件发生时由另外的一方调用的，用于对该事件或条件进行响应。

2.常见的回调函数调用：qsort()--快速排序的库函数，什么类型的数据都可以排序

（1）void*--无具体类型的指针，能够接收任意类型的地址，缺点：不能进行运算。（因为无类型，你不知道它加减整数和解引用时跳几个字节）

int a = 10; void* p = &a; p++;//error

（2）qsort()这个库函数需要引用头文件<stdlib.h>或<search.h>

其函数声明为：void qsort( void *base, size_t num, size_t width, int (*cmp )(const void *elem1, const void *elem2 ) );

①base：要排列的数据的开始

②num:要排序的元素个数

③width:一个元素的大小，单位是字节

④int (*cmp )(const void *elem1, const void *elem2 )：cmp指向的是：排序时：用来比较2个元素的函数

compare( (void *) elem1, (void *) elem2 );qsort在排序过程中调用该函数一次或多次，该函数比较两个元素并返回指定其关系的值，每次调用函数都会有返回值，如图：

当elem1>elem2时，qsort将调换两元素之间的位置，这是一个升序排序，如果想降序，可以转换大于和小于的含义，即elem1<elem2时，qsort才调换两元素之间的位置。

（3）举例：比较整型数据的大小、结构体内容，看如下代码：

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
struct Stu
{char name[20];int age;
};
//比较整型数据的大小
int cmp_int(const  void* e1, const void* e2)
{return *(int*)e1 - *(int*)e2;//e1，e2为void*，无法解引用，所以强制类型转换int*//此处为升序，如果想降序，可以return *(int*)e2 - *(int*)e1;
}
//比较结构体内容
int cmp_by_name(const void* e1, const void* e2)
{return strcmp(((struct Stu*)e1)->name, ((struct Stu*)e2)->name);
}int main()
{int arr[] = { 1,5,8,9,0,2,3,7,4,6 };struct Stu s[3] = { {"张三",15},{"李四",30},{"王五",10} };int sz = sizeof(arr) / sizeof(arr[0]);int sz = sizeof(s) / sizeof(s[0]);qsort(arr, sz, sizeof(arr[0]), cmp_int);//将数组中元素排序qsort(s, sz, sizeof(s[0]), cmp_by_name);//按照名字排序return 0;
}

调试结果如下：

注意：cmp_int,cmp_by_name这两个函数不是我们去调用的，而是我们把它的地址传给qsort，由qsort调用的