C语言指针详解（下）

正文开始前我们先来回忆一下C语言指针详解（上）的一些重点：

指针就是个变量，用来存放地址，地址唯一标识一块内存空间。

指针的大小是固定的4/8个字节（32位平台/64位平台）。

指针是有类型，指针的类型决定了指针的±整数的步长，指针解引用操作的时候的权限。

指针 - 指针计算的是指针间的元素个数。

下面开始我们的正文

文章目录：

1.字符指针
2.指针数组和数组指针
- 2.1指针数组
- 1.2数组指针
- 1.3&数组名和数组名
2.数组参数和指针参数
- 2.1一维数组传参
- 2.2二维数组传参
- 2.3一级指针传参
- 2.4二级指针传参
3.函数指针
4.函数指针数组
5.指向函数指针数组的指针
6.回调函数
- 6.1qsort库函数
- - 6.1.1qsort排序整型数据
  - 6.1.2qsort排序结构体数据
- 6.2实现冒泡排序对任意类型数据排序

1.字符指针

我们前面已经了解到了，字符指针类型为char*，char*类型的指针是为了存放char类型变量的地址，在解引用时访问一个字节

下面我们来看一下它的另一种使用方式：

#include<stdio.h>
int main()
{char a[] = "happy new year";const char* p = &a;printf("%s\n", p);return 0;
}

这里是把整个字符串放到指针变量p里了吗？答案是否定的，我们有图有真相
这里我们发现p中存放的是a的地址，而a的地址是字符串首元素的也就是字符串中 ‘h’ 的地址，所以上面代码的意思是把一个常量字符串的首字符 h 的地址存放到指针变量 p 中。
结论：

字符指针变量存放字符串地址时存放的是字符串首元素的地址

下面我们再来看一个例题：

#include <stdio.h>
int main()
{char str1[] = "happy new year.";char str2[] = "happy new year";const char* str3 = "happy new year";const char* str4 = "happy new year";if (str1 == str2)printf("str1 and str2 are same\n");elseprintf("str1 and str2 are not same\n");if (str3 == str4)printf("str3 and str4 are same\n");elseprintf("str3 and str4 are not same\n");return 0;
}
//str1and str2 are not same
//str3and str4 are same

这里为什么会输出这个结果呢？原因是这样的：
这里str3和str4指向的是一个同一个常量字符串。C/C++会把常量字符串存储到单独的一个内存区域，当几个指针指向同一个字符串的时候，他们实际会指向同一块内存。但是用相同的常量字符串去初始化不同的数组的时候就会开辟出不同的内存块。所以str1和str2不同，str3和str4不同。

2.指针数组和数组指针

2.1指针数组

指针数组是数组，是个存放指针的数组

这些在前面前面C语言指针详解（上）我们已经讲过了，这里我再举个栗子加深印象

#include<stdio.h>
int main()
{char* arr[3] = { "zhangsan","lisi","wangwu" };int i = 0;for (i = 0; i < 3; i++){printf("%s\n", arr[i]);}return 0;
}
//zhangsan
//lisi
//wangwu

1.2数组指针

数组指针是指针，是能够指向数组的指针。
例如：int(* p)[10]就是一个数组指针，p先和*结合，说明p是一个指针变量，指向的是一个大小为10个整型的数组

用数组指针打印二维数组

#include<stdio.h>
void print(int(*p)[5], int r, int c)
{int i = 0;for (i = 0; i < r; i++){int j = 0;for (j = 0; j < c; 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(arr, 3, 5);//数组名arr，表示首元素的地址//但是二维数组的首元素是二维数组的第一行//所以这里传递的arr，其实相当于第一行的地址，是一维数组的地址，可以数组指针来接收return 0;
}

我们再来看一下int (* p[10])[5]是什么意思
这里我们将其拆开，就成了int(*)[5]和p[10]，所以p就是存放5个数组指针的数组

1.3&数组名和数组名

我们知道数组名就是数组首元素的地址，那么&数组名的本质有是什么呢？来看个图：
这里虽然arr和&arr的值是一样的，但是意义是不同的，arr的类型是int*，是一个整型指针类型，+1跳过一个整型，所以 arr+1 相对于 arr 的差值是4，&arr 的类型是 int(*)[10] ，是一种数组指针类型数组的地址+1，跳过整个数组的大小，所以 &arr+1 相对于 &arr 的差值是40
结论：

&arr 表示的是数组的地址，而不是数组首元素的地址

2.数组参数和指针参数

2.1一维数组传参

举起两个栗子：

int arr[10] = {0},可以用int arr[10],int arr[],int* arr来接收

int* arr[10] = {0},可以用int* arr[10],int** arr来接收

2.2二维数组传参

举起一个栗子：

int arr[3][5] = {0},可以用int arr[3][5],int arr[][5],int (*arr)[5]接收

2.3一级指针传参

#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};int *p = arr;int sz = sizeof(arr)/sizeof(arr[0]);//一级指针p，传给函数print(p, sz);return 0;
}

void test1(int *p){}，这里的int *p接收的参数为：&变量，数组名，指针

2.4二级指针传参

#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;
}

void test(int** p){}，这里的int** p接收的参数为：二级指针，&一级指针，指针数组

3.函数指针

我么们先来看一段代码图：

这里我们打印的是函数Add的地址，观察发现两个地址是一样的
实际上，函数名就是函数的地址，和数组不一样，Add和&Add都是函数的地址，没有区别
要存放函数的地址就需要函数指针了，拿存放函数Add为例

void(* pf)(int x,int y) 就是函数指针，这里void（*）(int x,int y)就是函数指针类型，指向函数，指向的函数参数为int x和int y，返回值为void

我们运用函数指针来将改造一下上面的代码：

void Add(int x, int y)
{return x + y;
}
int main()
{//int(*pf)(int x, int y) = Add;int(*pf)(int,int) = Add;int sum = pf(3, 3);printf("%d", sum);return 0;
}
//输出6

我们再来看看下面两句代码是什么意思：

(* (void ()())0)();
这里是把0当做一个函数的地址，将0直接转换成一个void ()()的函数指针，然后去调用0地址处的函数

void (* signal(int , void(*)(int)))(int);
上述代码是一次函数声明
声明的函数是signal
signal函数的第一个参数是int类型的
signal函数的第二个参数是一个指针函数类型，该函数指针指向的函数参数是int，返回类型是void
signal函数的返回类型也是一个函数指针类型，该函数指针指向的函数参数是int，返回类型是void

4.函数指针数组

要把函数的地址存到一个数组中，那这个数组就叫函数指针数组
函数指针数组的定义：例如，int (*p[10])(int x,int y);这里p是个有十个元素的数组，p中存放的内容就是函数指针。

我们运用函数指针来写一个计算器：

#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.mui        4.div ******\n");printf("***********  0.exit  ***********\n");printf("********************************\n");
}int main()
{int input = 0;int x = 0;int y = 0;int ret = 0;//函数指针数组 - 转移表int (*pfArr[])(int, int) = { 0,Add,Sub,Mul,Div };do{menu();printf("请选择:>");scanf("%d", &input);if (0 == input){printf("退出计算器\n");break;}if (input >= 1 && input <= 4){printf("请输入两个操作数:>");scanf("%d %d", &x, &y);ret = pfArr[input](x, y);printf("%d\n", ret);}else{printf("选择错误，请重新选择:>\n");}} while (input);return 0;
}

5.指向函数指针数组的指针

指向函数指针数组的指针是一个指针，指针指向一个数组，数组的元素都是函数指针

定义：

#include<stdio.h>
int Add(int x, int y)
{return x + y;
}
int main()
{//函数指针pfvoid (*pf)(const char*) = Add;//函数指针的数组pfArrvoid (*pfArr[5])(const char* str);pfArr[0] = Add;//指向函数指针数组pfunArr的指针ppfunArrvoid (*(*ppfArr)[5])(const char*) = &pfArr;return 0;
}

6.回调函数

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

我们运用回调函数来对上面的计算器进行改造：

回调函数
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");printf("******************************\n");
}void calc(int (*p)(int, int))
{int x = 0;int y = 0;int ret = 0;printf("请输入2个操作数：>");scanf("%d %d", &x, &y);ret = p(x, y);printf("%d\n", ret);
}
int main()
{int input = 0;do{menu();printf("请选择:>");scanf("%d", &input);switch (input){case 1:calc(Add);break;case 2:calc(Sub);break;case 3:calc(Mul);break;case 4:calc(Div);break;case 0:printf("退出计算器\n");break;default:printf("输入错误，请重新输入:>\n");break;}} while (input);return 0;
}

6.1qsort库函数

函数讲解：

函数功能：排序任意类型的数据
头文件：#include<stdlib.h>
void* base：待排序数据的起始地址
size_t num：待排序数据的元素个数
size_t size：待排序数据元素的大小（单位是字节）
int (* cmpar)(const void*, const void*) ：比较2个元素大小的函数指针
返回值：>0,，p1指向的元素在p2指向的元素之前；=0，p1指向的元素和p2指向的元素相同；<0，p1指向的元素在p2指向的元素之后

6.1.1qsort排序整型数据

//qsort排序整型数组
#include<stdio.h>
int cmp_int(const void* e1, const void* e2)
{return *(int*)e1 - *(int*)e2;
}
int main()
{int arr[10] = { 6,4,3,9,1,5,0,2,7,3 };int sz = sizeof(arr) / sizeof(arr[0]);qsort(arr, sz, sizeof(arr[0]), cmp_int);int i = 0;for (i = 0; i < sz; i++){printf("%d ", arr[i]);}return 0;
}
//0 1 2 3 4 5 6 7 8 9

6.1.2qsort排序结构体数据

按名字来排序

按名字来排序
#include<stdio.h>
#include<string.h>
#include<stdlib.h>
struct Stu
{char name[20];int age;
};
//按名字比较
int cmp_by_name(const void* e1, const void* e2)
{return strcmp(((struct Stu*)e1)->name, ((struct Stu*)e2)->name);
}int main()
{struct Stu s[] = { {"zhangsan",18},{"lisi",30},{"wangwu",24} };int sz = sizeof(s) / sizeof(s[0]);qsort(s, sz, sizeof(s[0]), cmp_by_name);int i = 0;for (i = 0; i < sz; i++){printf("%s %d\n", s[i].name, s[i].age);}return 0;
}//打印输出
//lisi 30
//wangwu 24
//zhangsan 18

按年龄来比较

//按年龄来排序
#include<stdio.h>
#include<string.h>
#include<stdlib.h>
struct Stu
{char name[20];int age;
};
//按年龄比较
int cmp_by_age(const void* e1, const void* e2)
{return  (((struct Stu*)e1)->age - ((struct Stu*)e2)->age);
}
int main()
{struct Stu s[] = { {"zhangsan",18},{"lisi",30},{"wangwu",24} };int sz = sizeof(s) / sizeof(s[0]);qsort(s, sz, sizeof(s[0]), cmp_by_age);int i = 0;for (i = 0; i < sz; i++){printf("%s %d\n", s[i].name, s[i].age);}return 0;
}//打印输出
//zhangsan 18
//wangwu 24
//lisi 30

看到这想必大家对qsort库函数的功能和使用都已经理解了，我们之前讲了冒泡排序，但是冒泡排序只能排序整型数据，下面我们就模仿qsort库函数，实现用冒泡排序对任意类型的数据排序

6.2实现冒泡排序对任意类型数据排序

代码实现：

//实现冒泡排序对任意类型数据排序
void Swap(char* buf1, char* buf2, int width)
{//挨个儿字节交换int i = 0;for (i = 0; i < width; i++){char tmp = *buf1;*buf1 = *buf2;*buf2 = tmp;buf1++;buf2++;}
}void bubble_sort2(void* base, int sz, int width, int(*cmp)(const void* e1, const void* e2))
{int i = 0;//一趟冒泡排序for (i = 0; i < sz - 1; i++){int j = 0;//每趟交换的次数for (j = 0; j < sz - 1 - i; j++){if (cmp((char*)base + j * width, (char*)base + (j + 1) * width) > 0){//交换Swap((char*)base + j * width, (char*)base + (j + 1) * width, width);}}}
}

我们来测试一下功能是否和我们预期的相同
排序整型数据：

void Swap(char* buf1, char* buf2, int width)
{//挨个儿字节交换int i = 0;for (i = 0; i < width; i++){char tmp = *buf1;*buf1 = *buf2;*buf2 = tmp;buf1++;buf2++;}
}void bubble_sort2(void* base, int sz, int width, int(*cmp)(const void* e1, const void* e2))
{int i = 0;//一趟冒泡排序for (i = 0; i < sz - 1; i++){int j = 0;//每趟交换的次数for (j = 0; j < sz - 1 - i; j++){if (cmp((char*)base + j * width, (char*)base + (j + 1) * width) > 0){//交换Swap((char*)base + j * width, (char*)base + (j + 1) * width, width);}}}
}int cmp_int(const void* e1, const void* e2)
{return *(int*)e1 - *(int*)e2;
}
int main()
{int arr[10] = { 6,4,3,9,1,5,0,2,7,3 };int sz = sizeof(arr) / sizeof(arr[0]);bubble_sort2(arr, sz, sizeof(arr[0]), cmp_int);int i = 0;for (i = 0; i < sz; i++){printf("%d ", arr[i]);}return 0;
}
//0 1 2 3 4 5 6 7 8 9

对结构体排序：
按姓名来排序

void Swap(char* buf1, char* buf2, int width)
{//挨个儿字节交换int i = 0;for (i = 0; i < width; i++){char tmp = *buf1;*buf1 = *buf2;*buf2 = tmp;buf1++;buf2++;}
}void bubble_sort2(void* base, int sz, int width, int(*cmp)(const void* e1, const void* e2))
{int i = 0;//一趟冒泡排序for (i = 0; i < sz - 1; i++){int j = 0;//每趟交换的次数for (j = 0; j < sz - 1 - i; j++){if (cmp((char*)base + j * width, (char*)base + (j + 1) * width) > 0){//交换Swap((char*)base + j * width, (char*)base + (j + 1) * width, width);}}}
}struct Stu
{char name[20];int age;
};
//按名字比较
int cmp_by_name(const void* e1, const void* e2)
{return strcmp(((struct Stu*)e1)->name, ((struct Stu*)e2)->name);
}int main()
{struct Stu s[] = { {"zhangsan",18},{"lisi",30},{"wangwu",24} };int sz = sizeof(s) / sizeof(s[0]);bubble_sort2(s, sz, sizeof(s[0]), cmp_by_name);
int i = 0;
for (i = 0; i < sz; i++)
{printf("%s %d\n", s[i].name, s[i].age);
}return 0;
}//打印输出
//lisi 30
//wangwu 24
//zhangsan 18

按年龄来排序

void Swap(char* buf1, char* buf2, int width)
{//挨个儿字节交换int i = 0;for (i = 0; i < width; i++){char tmp = *buf1;*buf1 = *buf2;*buf2 = tmp;buf1++;buf2++;}
}void bubble_sort2(void* base, int sz, int width, int(*cmp)(const void* e1, const void* e2))
{int i = 0;//一趟冒泡排序for (i = 0; i < sz - 1; i++){int j = 0;//每趟交换的次数for (j = 0; j < sz - 1 - i; j++){if (cmp((char*)base + j * width, (char*)base + (j + 1) * width) > 0){//交换Swap((char*)base + j * width, (char*)base + (j + 1) * width, width);}}}
}struct Stu
{char name[20];int age;
};
//按年龄比较
int cmp_by_age(const void* e1, const void* e2)
{return  (((struct Stu*)e1)->age - ((struct Stu*)e2)->age);
}
int main()
{struct Stu s[] = { {"zhangsan",18},{"lisi",30},{"wangwu",24} };int sz = sizeof(s) / sizeof(s[0]);bubble_sort2(s, sz, sizeof(s[0]), cmp_by_age);int i = 0;for (i = 0; i < sz; i++){printf("%s %d\n", s[i].name, s[i].age);}return 0;
}//打印输出
//zhangsan 18
//wangwu 24
//lisi 30

由上面的用例可见对冒泡排序的改造达到了我们目标要求
好了这次的内容到这里就结束了，请友友们慢慢品味，三连关注不迷路，后期会持续更新C语言干货！