【C语言】指针进阶

指针的主题，在初阶的《指针》章节已经接触过了，我们知道了指针的概念：

指针就是个变量，用来存放地址，地址唯一标识一块内存空间。
指针的大小是固定的4/8个字节（32位平台/64位平台）。
指针是有类型，指针的类型决定了指针的±整数的步长，指针解引用操作的时候的权限。
指针的运算。

这篇博客我们将继续探讨指针的高级主题。

字符指针

在指针的类型中我们知道有一种指针类型为字符指针 char* 。一般我们这样使用，代码示例如下：

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
 
int main()
{
	char ch = 'w';
	char* pc = &ch; //这里的pc就是字符指针
	return 0;
}

那么这里我再介绍另一种字符指针的写法，代码示例如下：

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
 
int main()
{
	char* p = "abcdef";//这里的“abcdef”可以看作是一个表达式，其值是首字符的地址
	//因此这串代码的意思是把字符串首元素地址存放到指针p中
	return 0;
}

这跟我们之前讲过的另一种写法类似（其实本质上也有一些不同之处），就是将 “abcdef” 创建成一个数组，然后将数组的首元素地址存放到指针p中，代码示例如下：

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
 
int main()
{
	char arr[] = "abcdef";
	char* p = arr;//数组名是首元素地址，相当于将a的地址放入P中
	return 0;
}

通过对代码的分析来看，两者都是将a的地址存放到p中，但是我们先前也提到过本质上也是有不同的：

在这里插入图片描述

通过对字符串进行修改的过程中（将 *p = ‘w’），前者出现程序崩溃的情况，后者则可以正常修改字符串内容。因此，我们要避免在写代码过程存在出现对指针指向的常量字符串进行修改，所以应该在前者前加上 const ，限制了 *p ，p 指向的内容不能被修改，const 的作用就是在代码过程中出现修改常量字符串时警告程序员。代码示例如下：

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
 
int main()
{
	const char* p = "abcdef";
	return 0;
}

易错例子：

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
 
int main()
{
	char str1[] = "hello bit.";
	char str2[] = "hello bit.";
	//先初始化了两个数组，然后将 hello bit. 放入数组中
	//两个数组分别对应两块不同的内存空间
	//str1指的是数组str1[]首元素地址
	//str2指的是数组str2[]首元素地址
	//因此 str1 不等于 str2
	const char* str3 = "hello bit.";
	const char* str4 = "hello bit.";
	//str3和str4都是指针，存放的是常量字符串"hello bit."
	//所指的都是同一块内存空间
	//因此 str3 等于 str4。
	if (str1 == str2)
		printf("str1 and str2 are same\n");
	else
		printf("str1 and str2 are not same\n");
	if (str3 == str4)
		printf("str3 and str4 are same\n");
	else
		printf("str3 and str4 are not same\n");
	return 0;
}

在这里插入图片描述

指针数组

字符数组：存放字符的数组，char arr1[10];

整型数组：存放整形的数组，int arr2[10];

指针数组：存放指针的数组。

字符指针数组：存放字符指针的数组，char* arr3[10];
整形指针数组：存放整形指针的数组，int* arr4[10];

字符指针数组的使用，代码示例如下：

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
 
int main()
{
	char* arr[] = { "abcdef","higklmn","opqrst" };
	int i = 0;
	for (i = 0; i < 3; i++)
	{
		printf("%s\n", arr[i]);
	}
	return 0;
}

在这里插入图片描述

整形指针数组的使用，代码示例如下：

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
 
int main()
{
	int arr1[] = { 1,2,3,4,5 };
	int arr2[] = { 6,7,8,9,10 };
	int arr3[] = { 11,12,13,14,15 };
	int* arr[] = { arr1,arr2,arr3 };
	//arr是一个存放整形指针的数组
	int i = 0;
	for (i = 0; i < 3; i++)
	{
		int j = 0;
		for (j = 0; j < 5; j++)
		{
			printf("%2d ", *(arr[i] + j));
			//printf("%d ", *(arr[i] + j))也可写为printf("%d ", arr[i][j]);
		}
		printf("\n");
	}
	return 0;
}

在这里插入图片描述

数组指针

整形指针：指向整形的指针，int a = 10 ；int* pa = &a;

字符指针：指向字符的指针，char ch = ‘w’；char* pc =&ch;

数组指针：指向数组的指针。

字符数组指针：指向字符数组的指针，char arr[10]；char (*pc)[10] = &arr；
整形数组指针：指向整形数组的指针，int arr[10]；int (*pa)[10] = &arr；

数组指针的定义

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
 
//指针数组：本质是数组，是一种存放指针的数组。
//数组指针：本质是指针，是一种指向数组的指针，存放的是数组的地址
 
int main()
{
	//指针数组
	char* arr[5];
	//数组指针
	int arr[5] = { 0 };
	int(*p)[5] = &arr;
	return 0;
}

&数组名VS数组名

我们大家在学习C语言的过程中经常将 arr 和 &arr 傻傻分不太清楚，我们知道arr是数组名，数组名表示数组首元素的地址。那&arr数组名到底是啥，下面通过一段代码来揭开大家多年的疑问：

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
//数组名绝大部分情况下是首元素的地址
//但是有两个例外：
// 1.sizeof(数组名)：sizeof内部单独放一个数组名的时候，数组名表示的是整个数组，计算得到的是数组的总大小
// 2.&数组名：这里的数组名表示整个数组，取出的是整个数组的地址，从地址值的角度来讲和数组首元素的地址是一样的，但是意义不一样
int main()
{
	int arr[10] = { 0 };
	printf("%d\n", sizeof(arr));
 
	printf("arr = %p\n", arr);
	printf("&arr= %p\n", arr + 1);
 
	printf("arr+1 = %p\n", &arr[0]);
	printf("&arr+1= %p\n", &arr[0] + 1);
 
	printf("arr+1 = %p\n", &arr);
	printf("&arr+1= %p\n", &arr + 1);
	return 0;
}

代码分析：

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
 
int main()
{
	int arr[10] = { 0 };
	printf("%d\n", sizeof(arr));
 
	printf("arr = %p\n", arr);//arr表示首元素的地址，类型是 int* 类型
	printf("arr+1 = %p\n", arr + 1);//+1就跳过4个字节
 
	printf("&arr[0] = %p\n", &arr[0]);//&arr[0]表示首元素的地址，类型是 int* 类型
	printf("&arr[0]+1= %p\n", &arr[0] + 1);//+1就跳过4个字节
 
	printf("&arr = %p\n", &arr);//&arr表示一个数组的地址，将其存放到数组指针中去：int (*p)[10] = &arr;
	printf("&arr+1= %p\n", &arr + 1);//类型 int (*)[10]，所以+1跳过去的就是指向的整个数组的大小
	return 0;
}

在这里插入图片描述

简单总结一下：其实&arr和arr，虽然值是一样的，但是意义应该不一样的。实际上 &arr 表示的是数组的地址，而不是数组首元素的地址。（细细体会一下）代码中 &arr 的类型是 int(*)[10] ，是一种数组指针类型数组的地址+1，跳过整个数组的大小，所以 &arr+1 相对于 &arr 的差值是40。

数组指针的使用

访问数组中的元素，不但可以使用下标来进行访问，而且还可以使用指针来进行访问，代码示例如下：

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
 
int main()
{
	int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };
	int sz = sizeof(arr) / sizeof(arr[0]);
	int i = 0;
 
	//使用下标进行访问
	for (i = 0; i < sz; i++)
	{
		printf("%d ", arr[i]);
	}
 
	//使用指针来访问
	int* p = arr;
	for (i = 0; i < sz; i++)
	{
		printf("%d ", *(p + i));
	}
 
	//使用数组指针来访问，可以用，但是不推荐，有些复杂
	int (*p)[10] = &arr;
	for (i = 0; i < sz; i++)
	{
		printf("%d ", *((*p) + i));
	}
	return 0;
}

我们知道一维数组传参是，形参既可以写成数组也可以写成指针，代码示例如下：

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
 
//一维数组传参，参数是数组
void print(int arr[10], int sz)
{
	int i = 0;
	for (i = 0; i < sz; i++)
	{
		printf("%d ", arr[i]);
	}
	printf("\n");
}
 
//一维数组传参，参数是指针
void print(int （*arr）[10], int sz)
{
	int i = 0;
	for (i = 0; i < sz; i++)
	{
		printf("%d ", *(（*arr） + i));//也可以写成 printf("%d ", arr[i]);
	}
	printf("\n");
}
 
int main()
{
	int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };
	int sz = sizeof(arr) / sizeof(arr[0]);
	print(arr, sz);
	return 0;
}

通过一维数组的传参，而且有了数组指针的学习，二维数组除了将形参写为数组形式，其实也可以写为指针形式，代码示例如下：

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
//二维数组传参，形参可写为二维数组
void print(int arr[3][5], int r, int c)
{
	int i = 0;
	for (i = 0; i < r; i++)
	{
		int j = 0;
		for (j = 0; j < c; j++)
		{
			printf("%2d ", arr[i][j]);
		}
		printf("\n");
	}
}
//二维数组传参，形参可写为数组指针
void print(int(*arr)[5], int r, int c)
{
	int i = 0;
	for (i = 0; i < r; i++)
	{
		int j = 0;
		for (j = 0; j < c; j++)
		{
			printf("%2d ",*(*(arr+i)+j));    //*(arr+i)==arr[i]==&arr[i][j]
			//也可写为arr[i][j]
		}
		printf("\n");
	}
 
}
 
int main()
{
	int arr[3][5] = { 1,2,3,4,5, 6,7,8,9,10, 11,12,13,14,15 };
	//数组名arr，表示首元素的地址
    //但是二维数组的首元素是二维数组的第一行
    //所以这里传递的arr，其实相当于第一行的地址，是一维数组的地址
	print(arr, 3, 5);
	return 0;
}

在这里插入图片描述

数组参数、指针参数

一维数组传参

一维数组传参，形参可以是数组，也可以是指针，当形参是指针，要注意指针类型不要写错。

#define _CRT_SECURE_NO_WARNINGS
#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 main()
{
	int arr[10] = { 0 };
	int* arr2[20] = { 0 };
	test(arr);
	test2(arr2);
}

二维数组传参

二维数组传参，形参可以是数组，也可以是指针。当形参是数组，行可以省略，列不能省略。如果形参是指针，传过去的是第一行的地址，形参就应该是数组指针。

#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
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);
}

一级指针传参

#define _CRT_SECURE_NO_WARNINGS
#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]);
	print(p, sz);
	return 0;
}

那么思考一下，当函数的参数为一级指针的时候，可以接收什么参数？

在这里插入图片描述

二级指针传参

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

那么思考一下，当函数的参数为二级指针的时候，可以接收什么参数？

在这里插入图片描述

函数指针

函数指针：指向函数的指针。通过之前的学习我们知道数组指针中存放的是数组的地址，那么函数指针存放的是函数的地址吗？这里的答案是肯定的，代码示例如下：

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

在这里插入图片描述

我们可以观察到，函数指针确实可以得到函数的地址。C语言中函数名和&函数名都是函数地址。接下来，我将为大家说明函数地址怎样存起来，代码示例如下：

#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
int Add(int x, int y)
{
	return x + y;
}
int main()
{
	int(*pf)(int, int) = Add; //函数的地址要存起来，就得放在【函数指针变量】中去
    int ret = (*pf)(3,5); //使用指针进行函数调用
    //int ret = pf(3,5);
    //int ret = Add(3,5);
    //这三种写法都可以成功调用Add函数，其中第一种的*是一个摆设，写与不写都可以，写上是为了理解方便
    printf("%d\n",ret);
	return 0;
}

函数指针的写法说明示例：

在这里插入图片描述

下面来阅读两段有趣的代码：

//代码1
(*(void (*)())0)();

想要真正阅读这个代码的意思，分为以下几步：

将0强制类型转化为void(*)()类型的函数指针
这就意味着0地址处放着一个函数，函数没有参数，返回类型是void。
调用0地址处的这个函数。

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

代码二的括号内部是一个函数的声明，函数名字是signal，signal函数的第一个参数是 int 类型，第二个是 void(*)(int) 类型的函数指针，该函数指针指向的函数参数是 int ，函数返回类型为 void，signal 函数的返回类型也是一个函数指针。该函数指向的函数参数是 int ，返回类型为 void 。

这里给大家补充一个简化代码2的方法，代码示例如下：

#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
 
typedef int* ptr_t;    //将 int* 重新命名为 ptr_t
typedef void(*pf_t)(int); //意思是将 void(*)(int) 重新命名为 pf_t，pf_t是类型
 
int main()
{
	void(* signal( int, void(*)(int) ) )(int);
	//化简后
	pf_t signal(int, pf_t);
	return 0;
}

这里要注意区分：typedef void(*pf_t)(int)中的 pf_t 是类型名；不写 typedef 时，void(*pf)(int) 中的pf是指针变量的名字。

函数指针数组

我们之前了解了指针数组中的整形指针数组，知道它是一个数组，每个元素都是 int* 类型的指针，通过类比，我们可以推断出函数指针数组的每个元素都是一个函数指针。举一个例子吧，代码示例如下：

#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
int Add(int a, int b)
{
	return a + b;
}
int Sub(int a, int b)
{
	return a - b;
}
int Mul(int a, int b)
{
	return a * b;
}
int Div(int a, int b)
{
	return a / b;
}
int main()
{
	//存放函数指针的数组——函数指针数组
	int (*pf[4])(int, int) = { Add,Sub,Mul,Div };
	int i = 0;
	for (i = 0; i < 4; i++)
	{
		printf("%d ", pf[i](6, 4));
	}
	return 0;
}

在这里插入图片描述

函数指针数组应用实例

实现一个计算器，代码示例如下：

#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
 
void menu()
{
	printf("*************************\n");
	printf("****** 1:add 2:sub ******\n");
	printf("****** 3:mul 4:div ******\n");
	printf("****** 0.exit      ******\n");
	printf("*************************\n");
}
 
int Add(int a, int b)
{
	return a + b;
}
int Sub(int a, int b)
{
	return a - b;
}
int Mul(int a, int b)
{
	return a * b;
}
int Div(int a, int b)
{
	return a / b;
}
 
int main()
{
	int x = 0;
	int y = 0;
	int input = 1;
	int ret = 0;
	//转移表
	int (*pfArr[])(int, int) = { NULL,Add,Sub,Mul,Div };
	           //对应菜单的选项：0     1   2   3   4
	int sz = sizeof(pfArr) / sizeof(pfArr[0]);
	do
	{
		menu();
		printf("请选择：");
		scanf("%d", &input);
		if (input == 0)
		{
			printf("退出计算器。");
		}
		else if (input < sz)
		{
			printf("输入操作数：");
			scanf("%d %d", &x, &y);
			printf("%d\n", pfArr[input](x, y));
		}
		else
		{
			printf("选择错误\n");
		}
	} while (input);
	return 0;
}

这个计算器的实例利用了函数指针数组的优势，避免使用switch case语句，从而大大缩减了代码纵长，但是使用前提是函数的返回类型，参数个数和参数类型必须一致。我们称这种函数指针数组为转移表。

指向函数指针数组的指针

在这里简单复习一下前面学习的内容，指针数组，数组指针，函数指针，函数指针数组，代码示例如下：

#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
 
int my_strlen(const char* str)
{
	//……
	return 0;
}
 
int main()
{
	//指针数组
	int* arr[5] = { 0 };
 
	//数组指针
	int arr2[5] = { 0 };
	int (*p)[5] = &arr2;//p是一个指向数组的指针变量
 
	//函数指针
	int (*pf)(const char*) = my_strlen;//pf是一个指向函数的函数指针变量
	//如何调用函数：
	//写法一：（*pf)("abcdef")
	//写法二：my_strlen("abcdef") / pf("abcdef")
 
	//函数指针数组——存放函数指针的数组
	int(*pfArr[5]) = my_strlen;
 
	return 0;
}

其中要注意的是：由于函数名本质也是地址，因此不加&也是可以的。

指向函数指针数组的指针是一个指针，指针指向一个数组，数组的元素都是函数指针，代码示例如下：

#define _CRT_SECURE_NO_WARNINGS
#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[5])(int, int) = { Add,Sub };
	//指向函数指针数组的指针
	int (*(*ppfArr)[5])(int, int) = &pfArr;//ppfArr是一个指向函数指针数组的指针变量
	return 0;
}

回调函数

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

如果第一次没有看懂这句话的意思，没关系，我在这里就以上篇博客中的实现一个计算器的例子，使用回调函数来进行实现，代码示例如下：

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
 
void menu()
{
	printf("*************************\n");
	printf("****** 1:Add 2:Sub ******\n");
	printf("****** 3:Mul 4:Div ******\n");
	printf("*************************\n");
}
 
int Add(int a, int b)
{
	return a + b;
}
int Sub(int a, int b)
{
	return a - b;
}
int Mul(int a, int b)
{
	return a * b;
}
int Div(int a, int b)
{
	return a / b;
}
int main()
{
	int x, y;
	int input = 1;
	int ret = 0;
	do
	{
		menu();
		printf("请选择：");
		scanf("%d", &input);
		switch (input)
		{
		case 1:
			printf("输入操作数：");
			scanf("%d %d", &x, &y);
			ret = Add(x, y);
			printf("ret = %d\n", ret);
			break;
		case 2:
			printf("输入操作数：");
			scanf("%d %d", &x, &y);
			ret = Sub(x, y);
			printf("ret = %d\n", ret);
			break;
		case 3:
			printf("输入操作数：");
			scanf("%d %d", &x, &y);
			ret = Mul(x, y);
			printf("ret = %d\n", ret);
			break;
		case 4:
			printf("输入操作数：");
			scanf("%d %d", &x, &y);
			ret = Div(x, y);
			printf("ret = %d\n", ret);
			break;
		case 0:
			printf("退出程序\n");
			break;
		default:
			printf("选择错误\n");
			break;
		}
	} while (input);
	return 0;
}

我们发现 switch case 语句中有大量重复的代码，非常挫，那我们就可以将重复部分封装为一个函数，再将不一样的运算部分的函数进行传递给封装的函数就应该可以了，这个过程就被称为回调函数，代码优化示例如下：

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
 
void menu()
{
	printf("*************************\n");
	printf("****** 1:Add 2:Sub ******\n");
	printf("****** 3:Mul 4:Div ******\n");
	printf("*************************\n");
}
 
int Add(int a, int b)
{
	return a + b;
}
int Sub(int a, int b)
{
	return a - b;
}
int Mul(int a, int b)
{
	return a * b;
}
int Div(int a, int b)
{
	return a / b;
}
 
void Calc(int(*pf)(int,int))
{
	int x = 0;
	int y = 0;
	int ret = 0;
	printf("输入操作数：");
    scanf("%d %d", &x, &y);
    ret = pf(x, y);
    printf("ret = %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;
}

qsort函数

qsort 是一个库函数(quicksort)，被用来排序的库函数，并且是使用快速排序的方法进行排序。qsort 底层用的是快速排序的算法，不是我们之前用过的冒泡排序。

qsort 函数的几个优点：

是现成的，可以直接使用。
可以排序任何类型的数据

qsort 函数的具体形式，代码示例如下：

void qsort(void* base, //指向待排序数组的第一个元素
	       size_t num, //待排序的元素个数
	       size_t size,//每个元素的大小，单位是字节
	       int(*cmp)(const void*, const void*) //指向一个函数，这个函数可以比较两个元素的大小
          )

利用 qsort 函数对元素进行排序，代码示例如下：

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include<stdlib.h>
 
//qsort函数的使用者提供这个函数
int cmp_int(const void* p1, const void* p2)
{
	//排升序
	return *(int*)p1 - *(int*)p2;
	//排降序
	//return *(int*)p2 - *(int*)p1;
}
 
void print_arr(int arr[], int sz)
{
	int i = 0;
	for (i = 0; i < sz; i++)
	{
		printf("%d ", arr[i]);
	}
}
 
test1()
{
	int arr[] = {3,5,8,2,4,1,6,9,4,7,0};
	int sz = sizeof(arr) / sizeof(arr[0]);
	//使用qsort函数来排序整形数组，这里就要提供一个比较函数，这个比较函数能够比较两个整数的大小
	//qsort函数默认排成升序，要想排成降序需要在比较函数那里做文章
	qsort(arr, sz, sizeof(arr[0]), cmp_int);
	print_arr(arr, sz);
}
 
int main()
{
	test1();
	return 0;
}

大家要注意的是，这里第一次使用 void* 的指针，就简单说明一下void* 的作用吧：

void* ：无具体类型的指针，它可以接受任何类型的地址，void*类型指针解引用时会出现非法寻址，正是因为它无具体类型，因此在进行解引用时到底是访问几个字节，这就是一个问题。在使用无具体类型指针的解引用时，通常进行强制类型转换后在对其进行解引用。

int main()
{
	int a = 10;
	int* p = &a;//ok
	char* p = &a;//err
	void* p = &a;//ok
	return 0;
}

通过对以上的例子的解读和说明，相信大家也对qsort函数的基本用法也有了一些了解，接下来我们一起再看看qsort函数是怎样排序结构体函数的。

按照年龄进行排序：

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include<stdlib.h>
 
struct Stu
{
	char name[20];
	int age;
};
 
int cmp_stu_by_age(const void* p1, const void* p2)
{
	return ((struct Stu*)p1)->age - ((struct Stu*)p2)->age;
}
 
test2()
{
	struct Stu s[] = { {"zhangsan",50}, {"lisi",30}, {"wangwu",23} };
	int sz = sizeof(s) / sizeof(s[0]);
	qsort(s, sz, sizeof(s[0]), cmp_stu_by_age);
}
 
int main()
{
	test2();
	return 0;
}

调试结果如下：

在这里插入图片描述

按照名字进行排序：

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include<stdlib.h>
#include<string.h>
 
struct Stu
{
	char name[20];
	int age;
};
 
int cmp_stu_by_name(const void* p1, const void* p2)
{
	return strcmp(((struct Stu*)p1)->name , ((struct Stu*)p2)->name);
}
 
test2()
{
	struct Stu s[] = { {"zhangsan",50}, {"lisi",30}, {"wangwu",23} };
	int sz = sizeof(s) / sizeof(s[0]);
	qsort(s, sz, sizeof(s[0]), cmp_stu_by_name);
}
 
int main()
{
	test2();
	return 0;
}

调试结果如下：

在这里插入图片描述

模拟实现qsort（采用冒泡的方式）

qsort 底层是快速排序，但是因为还没有了解到快速排序的思想，因此这篇博客使用冒泡排序的思想来实现一个类似于 qsort 这个功能的冒泡排序函数 bubble_sort()。

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include<stdlib.h>
 
int cmp_int(const void* p1, const void* p2)
{
	return *(int*)p1 - *(int*)p2;
}
 
void print_arr(int arr[], int sz)
{
	int i = 0;
	for (i = 0; i < sz; i++)
	{
		printf("%d ", arr[i]);
	}
}
 
void Swap(char*buf1, char*buf2,size_t width)
{
	int i = 0;
	for (i = 0; i < width; i++)
	{
		char tmp = *buf1;
		*buf1 = *buf2;
		*buf2 = tmp;
		buf1++;
		buf2++;
	}
}
 
//希望这个bubble_sort可以排序任意类型的数据
void bubble_sort(void* base, size_t num, size_t width, int (*cmp)(const void* p1, const void* p2))
{
	//确定趟数
	size_t i = 0;
	for (i = 0; i < num - 1; i++)
	{
		//一趟冒泡排序的过程
		size_t j = 0;
		for (j = 0; j < num - 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);
			}
		}
	}
}
 
test3()
{
	int arr[] = { 3,5,8,2,4,1,6,9,4,7,0 };
	int sz = sizeof(arr) / sizeof(arr[0]);
	bubble_sort(arr, sz, sizeof(arr[0]), cmp_int);
	print_arr(arr, sz);
}
 
int main()
{
	test3();
	return 0;
}

代码思路分析：

在这里插入图片描述
排序结构体：

1. 按照年龄进行排序：

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include<stdlib.h>
 
struct Stu
{
	char name[20];
	int age;
};
 
int cmp_stu_by_age(const void* p1, const void* p2)
{
	return ((struct Stu*)p1)->age - ((struct Stu*)p2)->age;
}
 
void Swap(char*buf1, char*buf2,size_t width)
{
	int i = 0;
	for (i = 0; i < width; i++)
	{
		char tmp = *buf1;
		*buf1 = *buf2;
		*buf2 = tmp;
		buf1++;
		buf2++;
	}
}
 
//希望这个bubble_sort可以排序任意类型的数据
void bubble_sort(void* base, size_t num, size_t width, int (*cmp)(const void* p1, const void* p2))
{
	//确定趟数
	size_t i = 0;
	for (i = 0; i < num - 1; i++)
	{
		//一趟冒泡排序的过程
		size_t j = 0;
		for (j = 0; j < num - 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);
			}
		}
	}
}
 
test4()
{
	struct Stu s[] = { {"zhangsan",50}, {"lisi",30}, {"wangwu",23} };
	int sz = sizeof(s) / sizeof(s[0]);
	bubble_sort(s, sz, sizeof(s[0]), cmp_stu_by_age);
}
 
int main()
{
	test4();
	return 0;
}

2. 按照名字进行排序：

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include<stdlib.h>
 
struct Stu
{
	char name[20];
	int age;
};
 
int cmp_stu_by_name(const void* p1, const void* p2)
{
	return strcmp(((struct Stu*)p1)->name, ((struct Stu*)p2)->name);
}
 
 
void Swap(char*buf1, char*buf2,size_t width)
{
	int i = 0;
	for (i = 0; i < width; i++)
	{
		char tmp = *buf1;
		*buf1 = *buf2;
		*buf2 = tmp;
		buf1++;
		buf2++;
	}
}
 
//希望这个bubble_sort可以排序任意类型的数据
void bubble_sort(void* base, size_t num, size_t width, int (*cmp)(const void* p1, const void* p2))
{
	//确定趟数
	size_t i = 0;
	for (i = 0; i < num - 1; i++)
	{
		//一趟冒泡排序的过程
		size_t j = 0;
		for (j = 0; j < num - 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);
			}
		}
	}
}
 
test4()
{
	struct Stu s[] = { {"zhangsan",50}, {"lisi",30}, {"wangwu",23} };
	int sz = sizeof(s) / sizeof(s[0]);
	bubble_sort(s, sz, sizeof(s[0]), cmp_stu_by_name);
}
 
int main()
{
	test4();
	return 0;
}

对模拟代码进行优化，加入flag：

void bubble_sort(void* base, size_t num, size_t width, int (*cmp)(const void* p1, const void* p2))
{
	//确定趟数
	size_t i = 0;
	for (i = 0; i < num - 1; i++)
	{
		int flag = 1;
		//一趟冒泡排序的过程
		size_t j = 0;
		for (j = 0; j < num - 1 - i; j++)
		{
			//两个相邻元素的比较
			if (cmp((char*)base + j * width, (char*)base + (j + 1) * width) > 0)
			{
				flag = 0;
				Swap((char*)base + j * width, (char*)base + (j + 1) * width, width);
			}
		}
		if (flag == 1)
		{
			break;
		}
	}
}

指针和数组笔试题解析

接下来带大家一起来练习一些容易让人凌乱的题目，通过这些题目来进一步加深和巩固对数组，指针，sizeof() 和 strlen() 使用的熟练度。话不多说，开始今天的内容：

简单复习一下数组和指针：

数组：能够存放一组相同类型的元素，数组的大小取决于数组的元素个数和元素类型。

指针：地址/指针变量，大小是4/8个字节。

数组是数组，指针是指针，二者是不等价的。但又存在一定的联系：

数组名是数组首元素的地址，这个地址就可以存放在指针变量中；因此我们就可以使用指针来遍历数组。

数组名：

大部分情况下数组名是数组首元素的地址，但是有两个例外：

sizeof(数组名)：这里的数组名表示整个数组，计算的是整个数组的大小。
&数组名：这里的数组名表示整个数组，取出的是整个数组的地址。

一维数组：

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
int main()
{
	int a[] = { 1,2,3,4 };
	printf("%d\n", sizeof(a));//16
	//sizeof(数组名)，计算的是数组总大小，单位是字节
	printf("%d\n", sizeof(a + 0));//4/8
	//+0不可以被忽略，因此 a+0 表示的是数组首元素的地址
	printf("%d\n", sizeof(*a));//4
	//a 表示的是数组首元素的地址，相当于 &a[0]
	//*a == *&a[0] == a[0]
	printf("%d\n", sizeof(a + 1));//4/8
	//a 是数组首元素的地址，类型是 int*
	//a+1 就是跳过一个 int* ，是第二个元素的地址
	printf("%d\n", sizeof(a[1]));//4
	printf("%d\n", sizeof(&a));//4/8
	//&a 取出的是数组的地址，数组的地址也是地址，大小是4/8个字节
	// int (*pa)[4] = &a
	printf("%d\n", sizeof(*&a));//16
	//*&a == a，sizeof(a)计算的是数组总大小
	printf("%d\n", sizeof(&a + 1));//4/8
	//&a 取出的是整个数组的地址，类型是int (*)[4]
	//&a+1 就跳过整个数组，指向的是紧跟数组后的地址
	printf("%d\n", sizeof(&a[0]));//4/8
	//&a[0] 取出数组首元素的地址
	printf("%d\n", sizeof(&a[0] + 1));//4/8
	//&a[0]+1 取出数组第二个元素的地址
	return 0;
}

字符数组：

必备知识清单：

sizeof 计算的是占用内存空间的大小，单位是字节，不关注内存中到底存放的是什么。
sizeof 不是函数，是操作符。
strlen 是函数。
strlen 针对字符串，求的是字符串的长度，本质上统计的是 \0 之前出现的字符个数。

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include<string.h>
int main()
{
	char arr[] = { 'a','b','c','d','e','f' };
	printf("%d\n", sizeof(arr));//6
	printf("%d\n", sizeof(arr + 0));//4/8
	//arr+0 是数组首元素的地址
	printf("%d\n", sizeof(*arr));//1
	//arr 数组首元素的地址，*arr 表示数组首元素 
	printf("%d\n", sizeof(arr[1]));//1
	printf("%d\n", sizeof(&arr));//4/8
	//&arr 取出的是数组的地址
	printf("%d\n", sizeof(&arr + 1));//4/8
	//&arr+1 跳过一个数组后的地址
	printf("%d\n", sizeof(&arr[0] + 1));//4/8
	//&arr[0] 数组首元素的地址，+1 数组第二个元素的地址
 
    printf("%d\n", strlen(arr));//随机值
	//arr 数组首元素地址
	printf("%d\n", strlen(arr + 0));//随机值
	//arr+0 数组首元素地址
	printf("%d\n", strlen(*arr));//非法访问
	//*arr 代表首元素，但是 strlen 函数需要的是地址，因此将字符的ASCLL吗作为地址给strlen传去
	printf("%d\n", strlen(arr[1]));//非法访问
	//arr[1] 代表数组第二个元素，但是 strlen 函数需要的是地址，因此将字符的ASCLL吗作为地址给strlen传去
	printf("%d\n", strlen(&arr));//随机值
	//&arr 数组的地址，传给strlen后从起始位置开始计算
	printf("%d\n", strlen(&arr + 1));//随机值-6
	//&arr+1 整个数组后的地址
	printf("%d\n", strlen(&arr[0] + 1));//随机值-1
	//&arr[0]+1 数组第二个元素的地址
	return 0;
}

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include<string.h>
int main()
{
	char arr[] = "abcdef";// a,b,c,d,e,f,\0
	printf("%d\n", sizeof(arr));//7
	//sizeof(arr) 计算的是整个数组的大小
	printf("%d\n", sizeof(arr + 0));//4/8
	//arr+0 首元素的地址
	printf("%d\n", sizeof(*arr));//1
	//*arr 数组首元素
	printf("%d\n", sizeof(arr[1]));//1
	//arr[1] 数组第二个元素
	printf("%d\n", sizeof(&arr));//4/8
	//&arr 取出的是整个数组的地址
	printf("%d\n", sizeof(&arr + 1));//4/8
	//&arr+1 整个数组后的地址
	printf("%d\n", sizeof(&arr[0] + 1));//4/8
	//&arr[0]+1 数组第二个元素的地址
 
 
	printf("%d\n", strlen(arr));//6
	//arr 首元素的地址
	printf("%d\n", strlen(arr + 0));//6
	//arr+0 首元素的地址
	printf("%d\n", strlen(*arr));//非法访问
	//*arr 代表首元素，但是 strlen 函数需要的是地址，因此将字符的ASCLL吗作为地址给strlen传去
	printf("%d\n", strlen(arr[1]));//非法访问
	//arr[1] 代表数组第二个元素，但是 strlen 函数需要的是地址，因此将字符的ASCLL吗作为地址给strlen传去
	printf("%d\n", strlen(&arr));//6
	//&arr 表示整个数组的地址，从起始位置开始计算
	printf("%d\n", strlen(&arr + 1));//随机值
	//&arr+1 数组后的地址
	printf("%d\n", strlen(&arr[0] + 1));//5
	//&arr[0]+1 数组第二个元素的地址
	return 0;
}

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include<string.h>
int main
{
    char* p = "abcdef";
	printf("%d\n", sizeof(p));//4/8
	//p 存放的是 字符串的起始地址，也就是a的地址
	printf("%d\n", sizeof(p + 1));//4/8
	//p 的类型是char*，+1就跳过一个char*，也就是说跳过一个字符的地址，相当于b的地址
	printf("%d\n", sizeof(*p));//1
	//*p 表示首字符
	printf("%d\n", sizeof(p[0]));//1
	//p[0]相当于*（p+0)，表示字符串首元素
	printf("%d\n", sizeof(&p));//4/8
	//&p 取出的是指针变量在内存中的地址
	printf("%d\n", sizeof(&p + 1));//4/8
	//&p+1 跳过p的地址，但还是一个地址
	printf("%d\n", sizeof(&p[0] + 1));//4/8
	//&p[0]+1 得到a的地址，再跳过去，得到的就是b的地址
 
 
	printf("%d\n", strlen(p));//6
	printf("%d\n", strlen(p + 1));//5
	printf("%d\n", strlen(*p));//非法访问
	printf("%d\n", strlen(p[0]));//非法访问
	printf("%d\n", strlen(&p));//随机值
	printf("%d\n", strlen(&p + 1));//随机值
	printf("%d\n", strlen(&p[0] + 1));//5
    
    return 0;
}

二维数组：

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include<string.h>
int main()
{
	int a[3][4] = { 0 };
	printf("%d\n", sizeof(a));//48
	//二维数组的数组名a单独放在sizeof内部,计算的是整个数组的大小
	printf("%d\n", sizeof(a[0][0]));//4
	//a[0][0] 第一行第一个元素
	printf("%d\n", sizeof(a[0]));//16
	//a[0] 第一行的数组名，数组名单独放在sizeof内部，计算的是第一行数组的大小
	printf("%d\n", sizeof(a[0] + 1));//4/8
	//a[0]+1 第一行第一个元素的地址，得到的是第一行第二个元素的地址
	printf("%d\n", sizeof(*(a[0] + 1)));//4
	//*(a[0]+1) 第一行第二个元素a[0][1]
	printf("%d\n", sizeof(a + 1));//4/8
	//a+1 跳过数组第一行，指向下一行起始的地址
	printf("%d\n", sizeof(*(a + 1)));//16
	//*(a+1) 第二行的元素
	printf("%d\n", sizeof(&a[0] + 1));//4/8
	//&a[0]+1 去除第一行地址，+1跳过后指向第二行起始地址
	printf("%d\n", sizeof(*(&a[0] + 1)));//16
	//*(&a[0]+1) 第二行的元素
	printf("%d\n", sizeof(*a));//16
	//*a 第一行的元素
	printf("%d\n", sizeof(a[3]));//16
	//由于sizeof内部的表达式是不会真正计算的，因此sizeof是通过括号内的类型来推断结果是多少
	return 0;
}

指针笔试题

笔试题1：

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include<string.h>
int main()
{
	int a[5] = { 1, 2, 3, 4, 5 };
	int* ptr = (int*)(&a + 1);
	printf("%d,%d", *(a + 1), *(ptr - 1));
	return 0;
}

在这里插入图片描述

笔试题2：

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include<string.h>
struct Test
{
	int Num;
	char* pcName;
	short sDate;
	char cha[2];
	short sBa[4];
}*p;
//假设p 的值为0x100000。 如下表表达式的值分别为多少？
//已知，结构体Test类型的变量大小是20个字节
int main()
{
    p = (struct Test*)0x100000;
	printf("%p\n", p + 0x1);
	printf("%p\n", (unsigned long)p + 0x1);
	printf("%p\n", (unsigned int*)p + 0x1);
	return 0;
}

在这里插入图片描述

笔试题3：

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
 
int main()
{
	int a[4] = { 1, 2, 3, 4 };
	int* ptr1 = (int*)(&a + 1);
	int* ptr2 = (int*)((int)a + 1);
	printf("%x,%x", ptr1[-1], *ptr2);
	return 0;
}

在这里插入图片描述

笔试题4：

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
 
int main()
{
	int a[3][2] = { (0, 1), (2, 3), (4, 5) };
	//                 1       3       5
	//逗号表达式的结果是最后一个表达式的结果
	int* p;
	p = a[0];
	printf("%d", p[0]);
	return 0;
}

在这里插入图片描述

笔试题5：

int main()
{
int a[5][5];
int(*p)[4];
p = a;
printf( "%p,%d\n", &p[4][2] - &a[4][2], &p[4][2] - &a[4][2]);
return 0;
}

在这里插入图片描述

笔试题6：

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
 
int main()
{
	int aa[2][5] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
	int* ptr1 = (int*)(&aa + 1);
	int* ptr2 = (int*)(*(aa + 1));
	printf("%d,%d", *(ptr1 - 1), *(ptr2 - 1));
	return 0;
}

在这里插入图片描述

笔试题7：

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
 
int main()
{
	char* a[] = { "work","at","alibaba" };
	char** pa = a;
	pa++;
	printf("%s\n", *pa);
	return 0;
}

在这里插入图片描述

笔试题8：

int main()
{
    char *c[] = {"ENTER","NEW","POINT","FIRST"};
    char**cp[] = {c+3,c+2,c+1,c};
    char***cpp = cp;
    printf("%s\n", **++cpp);
    printf("%s\n", *--*++cpp+3);
    printf("%s\n", *cpp[-2]+3);
    printf("%s\n", cpp[-1][-1]+1);
    return 0;
}