什么是指针，我们在之前的《指针》章节已经接触过了，我们知道了指针的概念:
1.指针就是个变量，用来存放地址，地址唯一标识一块内存空间。
2指针的大小是固定的4/8个字节（ 32位平台/64位平台)。
3.指针是有类型，指针的类型决定了指针的+-整数的步长，指针解引用操作的时候的权限。
4.指针的运算。可以比较大小，如果两个指针指向同一数组，也可以相减，得到数的绝对值是之间的元素个数。
1.字符指针
在指针类型中，我们知道有一种指针类型为字符指针 char* ；
一般使用情况：
int main() { char ch = 'w'; char* pc = &ch;//pc就是字符指针，指向字符的指针就是字符指针 *pc = 'w'; return 0; }
还有一种使用情况如下：存放常量字符串的首字符的地址
#include<stdio.h> int main() { //下面右边是一个表达式，表达式的值是首字符的地址 char* p = "abcdef";//是把首字符的地址放到p中 //*p = 'w';//错误，这里字符串是常量字符串，不能修改 //const char *p = "abcdef";//这样写会更加严谨， char arr[] = "abcdef"; //可以想象为字符串是arr,p是存放的arr的首元素地址 char* parr = arr; // p指向的是arr首元素地址，不同的是arr数组是可以修改 *parr='w';//可以修改arr字符串的值 printf("%s\n", arr); return 0; }
代码 char* p = "abcdef"; 特别容易让我们以为是把字符串 abcdef 放到字符指针 p 里了，但是/本质是把常量字符串 abcedf 首字符的地址放到了p中，也就是a的地址放到了指针变量p中。
看一下面这道题
#include <stdio.h> int main() { char str1[] = "hello xilanhua"; char str2[] = "hello xilanhua"; const char* str3 = "hello xilanhua"; const char* str4 = "hello xilanhua"; if (str1 == str2) { printf("str1 和 str2 相等\n"); } else { printf("str1 和 str2 不相等\n"); } if (str3 == str4) { printf("str3 和 str4 相等\n"); } else { printf("str3 和 str4 不相等\n"); } return 0; }
str1 和str2 是两个字符数组的首元素地址，在内存中开辟不同的空间，所以str1和str2不相等，
str3 , str4 存放常量字符串 "hello xilanhua" 的首字符地址，常量字符串不能被修改，所以在内存中没有必要存两份，只需要开辟一份空间，两个指针都指向的这份空间，所以两个地址相同的。
所以输出结果为
2.指针数组
可以通过类比：
整型数组，存放整形的数组
字符数组，存放字符的数组
指针数组，存放指针的数组。
int* arr1[5];//整形指针数组 char* arr2[5];//一级字符指针的数组 char** arr3[5];//二级字符指针的数组
根据上面学的字符指针，我们看一下下面代码：
#include <stdio.h> int main() { char* arr[] = { "abcdef","hehe","xilanhua" };//字符指针数组 // arr0 arr1 arr2 //这里存放的是常量字符串的首字符的地址 //*arr[1] = 'w';//错误，这里数组元素指向的也是常量字符串，不能修改 for (int i = 0; i < 3; i++) { printf("%s\n", 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 }; //数组名是首元素地址 //arr是存放整形指针的数组 指针数组 int* arr[] = { arr1,arr2,arr3 }; int i = 0; int j = 0; for (i = 0; i < 3; i++) { for (j = 0; j < 5; j++) { printf("%d ", arr[i][j]);//和二维数组很像 //printf("%d ", *(arr[i] + j)); //*(arr[i]+j)==arr[i][j] arr[i]==*(arr+i) } printf("\n"); } return 0; }
结果：
可以发现和二维数组很像，但是本质上是不同的，二维数组是连续存放的空间，但是这里不是，是通过指针联系起来的。
3.数组指针
也是通过类比：
整形指针，指向整形的指针变量
字符指针，指向字符的指针变量
数组指针，指向数组的指针变量
下面哪一个是数组指针？
int* p1[10];
int (*p2)[10];
解释：
int (*p)[10]
p先和*结合，说明p是一个指针变量，然后指着指向的是一个大小为10个整型的数组。所以p是一个指针，指向一个数组，叫数组指针。
这里要注意:[ ] 的优先级要高于*号的，所以必须加上(）来保证p先和*结合。不加（），就是指针数组。
1. &数组名 和 数组名
看下面代码：
#include<stdio.h> int main() { int arr[10] = { 0 }; printf("%p\n", arr);//数组名是首元素地址 两个例外 &数组名和sizeof(数组名) printf("%p\n", &arr[0]);//首元素地址 printf("%p\n", &arr); //三个数值上相等 printf("%p\n", arr + 1);//int* + 1 printf("%p\n", &arr[0] + 1);//int* + 1 printf("%p\n", &arr + 1);//加了40 int(*)[10]+1 int(*p)[10] = &arr; //int(*)[10] 这个数组指针的类型 return 0; }
根据上面的代码我们发现，其实&ar r和 arr，虽然值上是相同的，但是意义是不相同的。实际上:&arr表示的是数组的地址，而不是数组首元素的地址。（细细体会一下)。数组的地址+1，跳过整个数组的大小，所以 &arr+1 相对于&arr 的差值是40.
总结：
数组名是首元素地址 有两个例外 &数组名 和 sizeof(数组名)
1.sizeof(arr) - sizeof内部单独放一个数组名的时候，数组名表示整个数组，计算得到的是数组的大小
2.&arr - 这里的数组名表示的是整个数组，取出的是整个数组的地址，从地址值的角度来讲和数组的首元素地址是一样的，但是意义不一样
2.访问数组元素的不同方式
#include<stdio.h> int main() { int arr[10] = { 1,2,3,4,5,6,7,8,9,10 }; int i = 0; int sz = sizeof(arr) / sizeof(arr[0]); //下标形式访问数组 for (i = 0; i < sz; i++) { printf("%d ", arr[i]); } //使用指针访问数组 int* p = arr; for (i = 0; i < sz; i++) { for (i = 0; i < sz; i++) { printf("%d ", *(p + i)); } } //数组指针访问数组 虽然对，但是不推荐 int(*pa)[10] = &arr; //pa == &arr //*pa == *&arr //*pa == arr 数组名 不是两种特殊情况 是首元素地址 for (i = 0; i < sz; i++) { printf("%d ", *((*pa)+i));//(*pa)[i]; } return 0; }
注意：
int(*pa)[10] = &arr;
//pa == &arr
//*pa == *&arr
//*pa == arr 数组名 不是两种特殊情况 是首元素地址所以：数组指针 解引用 是数组首元素地址
3. 数组指针的使用
二维数组的传参要使用到指针数组。
#include<stdio.h> //普通接收二维数组传参形式 void print1(int arr[3][5], int r, int c) { int i = 0; int j = 0; for (i = 0; i < r; i++) { for (j = 0; j < c; j++) { printf("%d ", arr[i][j]); } printf("\n"); } } //二维数组传参用到数组指针 void print(int (*arr)[5], int r, int c)//指针形式接受 数组指针 { int i = 0; int j = 0; for (i = 0; i < r; i++)//arr+i是每一行 *(arr+i)是每一行的数组名 arr[i] 首元素地址就是每一行的第一个元素的地址 { for (j = 0; j < c; j++) { //printf("%d ", *(*(arr + i) + j));//解引用数组指针就是数组首元素地址，二维数组是第一行地址 printf("%d ", arr[i][j]);//*(*(arr+i)+j)==*(arr+i)[j]==arr[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(arr, 3, 5);//二维数组的数组名，也表示首元素地址 //二维数组的首元素地址是第一行的地址，存放的是一维数组 //可以理解为二维数组是存放一维数组的数组 return 0; }
二维数组的数组名，也表示首元素地址。二维数组的首元素地址是第一行的地址，存放的是一维数组。可以理解为二维数组是存放一维数组的数组
4.数组传参和指针传参
在写代码的时候难免要把【数组】或者【指针】传递给函数，那函数的参数该如何设计呢？
一维数组传参：
形参可以是数组，也可以是指针，当形参是指针时，要注意类型。
#include<stdio.h> void test(int arr[])//不会真的创建一个数组，不写大小 {} void test(int arr[10])//和传入格式一样，不会真的创建 {} void test(int* arr)//数组名，首元素地址，指针接受 {} void test2(int* arr[20])//指针数组，和传入格式一样 {} void test2(int** arr )//数组首元素是int* 类型，*arr说明他是指针 {} int main() { int arr[10] = { 0 };//整形数组 int* arr2[20] = { 0 };//整形指针数组 test(arr); test2(arr2); return 0; }
二维数组传参：
参数可以是指针，也可以是数组，如果是数组，行可以省略，列不能省略，如果是指针，传参传过去的是第一行的指针，形参就应该是数组指针
void test(int arr[3][5]) {} //void test(int arr[][])//错误，只能省略行，因为得知道一行有几个元素 //{} void test(int arr[][5]) {} //void test(int *arr)//错误，二维数组的首元素地址是第一行的地址 //{} //void test(int* arr[5])//错误，这是一个指针数组，存放整形指针的数组 //{} void test(int(*arr)[5])//数组指针，可以接收实参 {} //void test(int** arr)//错误，二级指针 //{} int main() { int arr[3][5] = { 0 }; test(arr); return 0; }
一级指针传参：
#include<stdio.h> void print(int* p, int sz) { int i = 0; for (i = 0; i < sz; i++) { printf("%d\n", *(p + i));//通过指针访问 } } int main() { int arr[10] = { 1,2,3,4,5,6,7,8,9,10 }; int* p = arr;//一级指针 int sz = sizeof(arr) / sizeof(arr[0]);//元素个数 print(p, sz); return 0; }
思考：当一个函数参数是一个指针时，函数能接收什么参数
void print(int* p);
1.int a;
print(&a);//变量的地址
2.int* p=&a;
print(p);//指针变量
3.int arr[10];
print(arr);//数组名
二级指针传参：
#include<stdio.h> //用二级指针接收 void test(int** ptr) { printf("num = %d\n", **ptr); } int main() { int n = 10; int* p = &n; int** pp = &p; test(pp); test(&p); return 0; }
思考：当函数的参数为二级指针的时候，可以接收什么参数
1.一级指针的地址
2.二级指针变量，
3.指针数组
5.函数指针
这里还是类比：
整形指针，指向整形的指针 int*
字符指针，指向字符的指针 char*
数组指针，指向数组的指针，int arr[10]; int (*p)[10] = &arr;
函数指针，指向函数的指针， 即存放函数的地址
那么问题来了，函数有地址吗
#include<stdio.h> int Add(int x, int y) { return x + y; } //&函数名得到就是函数的地址 int main() { printf("%p\n", &Add);//可以运行 printf("%p\n", Add);//可以运行 return 0; } //函数名 和 &函数名都是函数的地址
结果：
可以得出结论，函数名 和 &函数名 都是函数的地址。
使用函数指针调用函数:
#include<stdio.h> int Add(int x, int y) { return x + y; } int main() { //()是pf先于*结合，说明pf是指针 int (*pf)(int, int) = Add;//函数的地址要存起来，就得放在 函数指针变量pf 中 //最前面的是函数返回类型，后面括号内是函数参数类型 //通过函数指针调用函数 int ret = (*pf)(3, 5); ret = Add(3, 5);//函数可以这样调用，Add是地址 ret = pf(3, 5);//所以这样写也对 ret = (*****pf)(3, 5);//编译器在处理时，会把*去掉，也没有问题 printf("%d\n", ret);//8 return 0; }
可以阅读两段有趣的代码
1.(*(void(*)( ))0)( );
#include<stdio.h> int main() { //1.将0强制类型转换为void(*)()类型的函数指针 //2.这就意味着0地址处放着一个函数，函数无参，返回类型是void //3.调用0地址处的这个函数 (*(void(*)())0)();//前面*可以不写 return 0; }
2.void(* signal(int, void(*)(int) ) )(int);
int main() { void(* signal(int, void(*)(int) ) )(int); //signal先于（）结合 //void(*)(int) //signal(int, void(*)(int));//函数名称和函数参数类型 //上述代码是一个函数的声明， //函数的名字是signal //函数的参数第一个是int类型，第二个是void(*)(int)类型的函数指针 //该函数指针指向的函数参数是int,返回类型是void //signal函数的返回类型也是一个函数指针 //该函数指针指向的函数参数是int,返回类型是void return 0; } 可以通过类型重命名简化为： //typedef int(*)(int) pt_f;//写法不对 typedef void(*pf_t)(int);//将void(*)(int)类型的函数指针重命名叫pf_t pf_t(signal(int, pf_t));
6.函数指针数组
存放函数指针的数组
函数指针数组写法
函数指针 int (*p)(int,int); 函数指针数组只需在p后加一个[大小]，让指p先于[]结合 int (*p[10])(int,int); //数组存放元素的类型就是 int (*) （int,int)
函数指针数组的用途：转移表
例子：（计算器）
#include<stdio.h> int Add(int x, int y)//加法函数 { return x + y; } int Sub(int x, int y)//减法函数 { return x - y; } int Mul(int x, int y)//乘法函数 { return x * y; } int Div(int x, int y)//除法函数 { return x / y; } void menu()//菜单函数 { printf("************************\n"); printf("**** 1.add 2.sub ****\n"); printf("**** 3.mul 4.div ****\n"); printf("**** 0.exit ****\n"); } int main() { //转移表 - 函数指针数组 函数指针类型要相同 int(*pfArr[5])(int, int) = { NULL,Add,Sub,Mul,Div };//NULL==0 // 下标 0 1 2 3 4 int input = 0; int x = 0; int y = 0; int ret = 0; do { menu(); printf("请输入:> "); scanf("%d", &input); if (input == 0) { printf("退出计算器\n"); break; } if (input <= 4 && input >= 1) { printf("请输入两个操作数:>"); scanf("%d %d", &x, &y); printf("%d\n",pfArr[input](x, y));//调用相应的计算函数 } else { printf("输入非法，请重新输入\n"); } } while (input); return 0; }
7.指向函数指针数组的指针
指向函数指针数组的指针是一个指针，指针指向一个数组，数组的元素都是函数指针。
示例：
#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(*pfArr[4])(int, int) = { Add,Sub }; //ppfArr是一个指向一个函数指针数组的指针变量 int(*(*ppfArr)[4])(int,int) = &pfArr; return 0; }
8.回调函数
回调函数就是一个通过函数指针调用的函数。如果你把函数的指针（地址)作为参数传递给另一个函数，当这个指针被用来调用其所指向的函数时，我们就说这是回调函数。回调函数不是由该函数的实现方直接调用，而是在特定的事件或条件发生时由另外的一方调用的，用于对该事件或条件进行响应。
这里演示一个用到回调函数的库函数，qsort 函数，包含头文件 stdlib.h 。
我们通过c++官方网站旧版上可以查到 qsort 函数的用法qsort用法
先看返回值类型和参数列表
它可以排序任何类型的数据，但是需要自己写一个函数用来可以确定两个元素的大小，也就是参数列表中的compar函数。
void qsort( void* base,//待排序数组的第一个元素 size_t num, //待排序的元素个数 size_t size, //每个元素的大小 int(*cmp)(const void*, const void*));//函数指针，指向一个函数，这个函数可以比较2个元素的大小
qsort 函数底层使用的是快速排序，也是一种排序算法，我们这里用冒泡排序实现一下。
因为这个函数可以排序任何类型，所以我们最开始用 void * 指针来接收传来的指针，然后再通过强制类型转换 （char*) 再加上 size 来确定操作空间的大小。
我们先来实现以下cmp 函数
这是cmp函数的要求，返回值有大于0，小于0，和等于0，三种情况。 大于0指向p1，p1大，小于0指向p2，p2大,相等返回值是0。
int cmp_int(const void* p1, const void* p2) { return *(int*)p1 - *(int*)p2; //这是我们自己写的函数，我们知道是int类型，所以强制类型转换为(int*) }
交换函数：
因为我们不知道要交换什么类型元素，所以是使用 (char*) 强制类型转换，每次交换一个字节，循环size次的方法
void Swap(char* p1, char* p2, size_t size) { for (size_t i = 0; i < size; i++) { char t = *(p1 + i); *(p1 + i) = *(p2 + i); *(p2 + i) = t; } }
排序内部：
void bubble_sort(void* base, size_t num, size_t size, int(*cmp)(const void*, const void*)) { size_t i = 0; size_t j = 0; for (i = 0; i < num - 1; i++)//一趟冒泡排序 { for (j = 0; j < num - 1 - i; j++) { //两个相邻元素比较 //arr[j]与arr[j+1] 调用我们自己写的比较函数，回调函数 if (cmp((char*)base + j * size, (char*)base + (j + 1) * size) > 0) { //交换 Swap((char*)base + j * size, (char*)base + (j + 1) * size,size); } } }
全部代码：
#include<stdio.h> #include<stdlib.h> int cmp_int(const void* p1, const void* p2) { return *(int*)p1 - *(int*)p2; //这是我们自己写的函数，我们知道是int类型，所以强制类型转换为(int*) } void Swap(char* p1, char* p2, size_t size) { for (size_t i = 0; i < size; i++) { char t = *(p1 + i); *(p1 + i) = *(p2 + i); *(p2 + i) = t; } } void bubble_sort(void* base, size_t num, size_t size, int(*cmp)(const void*, const void*)) { size_t i = 0; size_t j = 0; for (i = 0; i < num - 1; i++)//一趟冒泡排序 { for (j = 0; j < num - 1 - i; j++) { //两个相邻元素比较 //arr[j]与arr[j+1] if (cmp((char*)base + j * size, (char*)base + (j + 1) * size) > 0) { //交换 Swap((char*)base + j * size, (char*)base + (j + 1) * size, size); } } } } int main() { int arr[10] = { 1,2,8,9,10,5,3,6,4,7 }; qsort(arr, 10, sizeof(arr[0]), cmp_int); for(int i=0;i<10;i++) { printf("%d ", arr[i]); } printf("\n"); int arr1[10] = { 1,2,8,9,10,5,3,6,4,7 }; bubble_sort(arr1, 10, sizeof(arr[0]), cmp_int); for (int i = 0; i < 10; i++) { printf("%d ", arr[i]); } return 0; }
本篇结束
