C语言_指针_进阶

本章重点

• 字符指针
• 数组指针
• 指针数组
• 数组传参和指针传参
• 函数指针
• 函数指针数组
• 指向函数指针数组的指针
• 回调函数
• 指针和数组面试题的解析

这个章节，我们继续探讨指针的高级主题。

1. 字符指针

在指针的类型中我们知道有一种指针类型为字符指针char*;

一般使用:

int main()
{
 	char ch = 'w';
 	char *pc = &ch;
 	*pc = 'w';
 	return 0;
}

还有一种使用方式如下：

int main()
{
 	char* pstr = "hello bit.";//这里是把一个字符串放到pstr指针变量里了吗？
	printf("%s\n", pstr);
 	return 0;
}

代码char* pstr = "hello bit."；特别容易让同学以为是把字符串hello bit 放到字符指针了，但是本质是把字符串pstr 里hello bit，首字符的地址放到了pstr中。

类似于int arr[3] = {1, 2, 3}; int* parr = arr。我们知道数组名就是首元素地址，那么将数组名当作地址存入parr的指针变量中。

一道面试题：

输出结果：

当我们往下面学习指针数组和数组指针的时候，就会产生一种没来由的困惑，读起来都有点绕口。其实辨别起来很简单：只需要去看最后两个字是什么。

指针数组：数组，装有指针元素的数组
数组指针：指针，指向数组的指针

2. 指针数组

在C语言_指针_初阶章节，我们也学了指针数组，指针数组是一个存放指针的数组。

这里我们再复习一下，下面指针数组是什么意思？

int* arr1[10]; //整形指针的数组
char *arr2[4]; //一级字符指针的数组
char **arr3[5];//二级字符指针的数组

3. 数组指针

3.1 数组指针的定义

数组指针是指针？还是数组？

答案是：指针。

我们已经熟悉了：整型指针：int* ptr；能够指向整形数据的指针。浮点型指针：float* ptr；能够指向浮点型数据的指针。

那数组指针也就很明确了：指向数组的指针。

下面代码哪个是数组指针？

int *p1[10];
//p1先跟[]结合，说明他是数组,[]里面是10，说明装有10个整型指针的元素。
int (*p2)[10];//数组指针
 //p1, p2分别是什么？

解释：

3.2 &数组名 VS 数组名

对于下面的数组：

arr 和 &arr 分别是啥？

我们知道arr是数组名，数组名表示数组首元素的地址。

那&arr数组名到底是啥？

我们看一段代码：

#include <stdio.h>
int main()
{
 	int arr[10] = {0};
 	printf("%p\n", arr);
 	printf("%p\n", &arr);
	return 0;
}

输出结果

可见数组名和&数组名打印的地址是一样的。

难道两个是一样的吗？

我们再看一段代码：

#include <stdio.h>
int main()
{
 	int arr[10] = { 0 };
 	printf("arr = %p\n", arr);
 	printf("&arr= %p\n", &arr);
 	
 	printf("arr+1 = %p\n", arr+1);
 	printf("&arr+1= %p\n", &arr+1);
 	return 0;
}

输出结果

从上面可知，数组名就是首元素的地址，那么sizeof(数组名)，难道取的是指针变量的字节嘛？

总结：

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

1.sizeof（数组名），这里面的数组名代表的是整个数组，所以取出来的字节也就是整个数组的字节。

2.&数组名，这里的数组名代表的也是整个数组，那么取出来的地址也就是整个数组的地址。

3.3 数组指针的使用

那数组指针是怎么使用的呢？

既然数组指针指向的是数组，那数组指针中存放的应该是数组的地址。

下面我们通过数组指针完成对数组内的元素进行一个遍历。

上面我们讲述了一维数组取地址变成数组指针的使用方式，下面我们来讲述二维数组取地址变成数组指针的使用方式，并且会画图详细的描述整个流程。

4. 数组参数、指针参数

4.1 一维数组传参

#include <stdio.h>
void test(int arr[])//ok?
//实参传递了数组名，形参就可以用数组类型进行接受
{}
void test(int arr[10])//ok?
//完全没问题
{}
void test(int *arr)//ok?
//指向int类型元素的地址，也就是指向首元素的地址。
{}
void test2(int *arr[20])//ok?
//完全没问题
{}
void test2(int **arr)//ok?
//(*arr)是一个指针，指向了一个int*类型的元素。
{}

int main()
{
	int arr[10] = {0};
	int *arr2[20] = {0};
	test(arr);
	test2(arr2);
}

4.2 二维数组传参

void test(int arr[3][5])//ok？
//完全没问题
{}
void test(int arr[][])//ok？
//不能省略一维数组中存储元素的个数。
{}
void test(int arr[][5])//ok？
//正确，可以省略二维数组的一维元素个数。
{}
//总结：二维数组传参，函数形参的设计只能省略第一个[]的数字。
//因为对一个二维数组，可以不知道有多少行，但是必须知道一行多少元素。
//这样才方便运算。
void test(int *arr)//ok？
//错误，形参的意思是指向整型元素的地址，跟题意完全不同。
{}
void test(int* arr[5])//ok？
//错误，形参是指针数组的意思，跟题意完全不同。
{}
void test(int (*arr)[5])//ok？
//正确，(*arr)是指针，指向了一个装有五个整型元素的数组。
{}
void test(int **arr)//ok？
//错误，首元素地址代表的是一维数组的整个数组地址。
{}

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

一级指针传参

#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 test(char* ptr)
{}

int main()
{
	char arr[10] = "abcdef";
	char ch = 'a';
	char* ptr = arr;
	test(arr);
	test(&ch);
	test(ptr);
	return 0;
}

二级指针传参

#include <stdio.h>
void test(int** ptr)
{
 	printf("num = %d\n", **ptr);    
}

int main()
{
 	int n = 10;
 	int*p = &n;
 	int **pp = &p;
 	int* arr[5];
 	test(pp);
 	test(&p);
 	test(arr);
 	return 0;
}

5. 函数指针

首先，我们看最后两位是指针，那么他其实就是指向函数的指针。

输出的是两个地址，这两个地址是test函数的地址。 那我们的函数的地址要想保存起来，怎么保存？

下面我们看代码：

void test(char* pc, int arr[10])
{}

int main()
{
	void (*ptr)(char*, int [10]) = &test;
	//&test跟test都能表达地址，可以省略&。
	return 0;
}

那么，我们既然知道了函数指针怎么创建，那下面我们就继续讨论，怎么使用函数指针。

聪明的朋友已经看出来了，add和&add都是代表着函数地址的意思，那么pf好像等价于add，那有没有可能pf(参数1，参数2)也可以进行函数调用呢？

阅读两段有趣的代码：

 (*(void (*)())0)();

 void (*signal(int , void(*)(int)))(int);

6. 函数指针数组

数组是一个存放相同类型数据的存储空间，那我们已经学习了指针数组， 比如：

int *arr[10];
//数组的每个元素是int*

那要把函数的地址存到一个数组中，那这个数组就叫函数指针数组，那函数指针的数组如何定义呢？

int (*parr1[10]])();

那么我们从这里就明白了，函数指针数组的写法，那么我们开拓一下思路，是不是也就知道了数组指针数组的写法？

int arr_1[5] = { 1, 2, 3, 4, 5 };
int arr_2[5] = { 1, 2, 3, 4, 5 };
int arr_3[5] = { 1, 2, 3, 4, 5 };
int (*parr[3])[5] = {&arr_1, &arr_2, &arr_3};

函数指针数组的用途：转移表

例子：（计算器）

//加法
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");
}

int main()
{
	int input = 0;
	int x = 0;
	int y = 0;
	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;
}

所以，衍生出了下面的这个方式，使用函数指针数组实现计算器：

//加法
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");
}

int main()
{
	int input = 0;
	int x = 0;
	int y = 0;
	int ret = 0;
	//函数指针数组
	int (*PfArr[5])(int, int) = {NULL, add, sub, mul, div};
	do
	{
		menu();
		printf("请选择：");
		scanf("%d", &input);
		if (input >= 1 && input <= 4)
		{
			printf("请输入两个数字：");
			scanf("%d %d", &x, &y);
			//通过函数指针数组调用函数 - 转移表
			//通过函数指针数组找到对应下标然后跳到该函数位置得到结果再次返回来。
			int ret = (*PfArr[input])(x, y);
			printf("ret = %d\n", ret);
		}
		else if (input == 0)
		{
			printf("退出计算器！！！\n");
		}
		else
		{
			printf("输入有误，请重新检查！！！\n");
		}
	} while (input);
	return 0;
}

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

其实很好理解，指针指向了一个数组，数组里面的元素都是函数指针。

void test(const char* str)
{
 	printf("%s\n", str);
}

int main()
{
	//函数指针
	void(*pf)(const char*) = &test;
	//函数指针数组
	void(*pf[5])(const char*);
	//指向函数指针数组的指针
	void(*(*pf)[5])(const char*);
	//再次拓展
	//指向函数指针数组的指针的数组
	void(*(*pf[5])[5])(const char*);
	return 0;
}

8. 回调函数

画图详解：

那我们知道了回调函数的概念，通过回调函数来继续实现计算器项目

//加法
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 Cacl(int(*pf)(int, int))
{
	int x = 0;
	int y = 0;
	printf("请输入两个数字：");
	scanf("%d %d", &x, &y);
	int ret = (*pf)(x, y);
	printf("ret = %d\n", ret);
}

int main()
{
	int input = 0;
	int x = 0;
	int y = 0;
	int ret = 0;
	do
	{
		menu();
		printf("请选择：");
		scanf("%d", &input);
		switch (input)
		{
		case 1:
			Cacl(add);
			break;
		case 2:
			Cacl(sub);
			break;
		case 3:
			Cacl(mul);
			break;
		case 4:
			Cacl(div);
			break;
		case 0:
			printf("退出计算器！！！\n");
			break;
		default:
			printf("输入有误，请重新输入！！！\n");
			break;
		}
	} while (input);
	return 0;
}

下面在讲qsort之前，我们先了解一下冒泡排序的思路。

其实冒泡排序的核心思路不难，就是通过相邻两个数字进行对比，不断的将一个最大值或者最小值挪到最右边，以上仅仅是一趟，我们要通过多躺实现最终的效果。

我们将冒泡排序再次复习一遍。

//冒泡排序
void Bubble_sort(int* arr, int sz)
{
	int i = 0;
	//趟数
	for (i = 0; i < sz - 1; i++)
	{
		int j = 0;
		//一趟比较的次数
		for (j = 0; j < sz - 1 - i; j++)
		{
			//相邻两个数字进行比对
			if (arr[j] < arr[j + 1])
			{
				//三个空杯子原理进行交换
				int tmp = arr[j];
				arr[j] = arr[j + 1];
				arr[j + 1] = tmp;
			}
		}
	}
}

//输出排序结果
void Printf(int* arr, int sz)
{
	int i = 0;
	for (i = 0; i < sz; i++)
	{
		printf("%d ", arr[i]);
	}
	return 0;
}

int main()
{
	int arr[10] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
	int sz = sizeof(arr) / sizeof(arr[0]);
	Bubble_sort(arr, sz);
	Printf(arr, sz);
	return 0;
}

输出结果：

首先演示一下qsort函数的使用：

#include <stdlib.h>
#include <string.h>

//void*指针 - 无具体类型指针
// void*指针可以接受任意类型的指针
//void*类型指针不能直接进行解引用访问
//也不能直接用来进行指针运算

//整型数组通过整型元素比较
int cmp_int(const void* p1, const void* p2)
{
	return *(int*)p2 - *(int*)p1;
}

//输出结果
void Printf(int* arr, int sz)
{
	int i = 0;
	for (i = 0; i < sz; i++)
	{
		printf("%d ", arr[i]);
	}
}

//测试qsort排序整型
void test1()
{
	int arr[10] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
	int sz = sizeof(arr) / sizeof(arr[0]);
	qsort(arr, sz, sizeof(int), cmp_int);
	Printf(arr, sz);
}

//测试qsort排序结构体
typedef struct Stu Stu;
struct Stu
{
	char name[20];
	int age;
};

//结构体通过年龄比较
int cmp_stu_by_age(const void* p1, const void* p2)
{
	return (((Stu*)p1)->age - ((Stu*)p2)->age);
}

//结构体通过名字比较
int cmp_stu_by_name(const void* p1, const void* p2)
{
	//名字不能直接相减，需要通过专门的字符比较函数 - strcmp
	return strcmp(((Stu*)p1)->name, ((Stu*)p1)->name);
}

void test2()
{
	Stu arr[3] = { {"XingC", 22}, {"qmx_07", 20}, {"Yuu", 21}};
	int sz = sizeof(arr) / sizeof(arr[0]);
	qsort(arr, sz, sizeof(arr[0]), cmp_stu_by_age);
	printf("%d\n", arr[2].age);
}

void test3()
{
	Stu arr[3] = { {"XingC", 22}, {"qmx_07", 20}, {"Yuu", 21} };
	int sz = sizeof(arr) / sizeof(arr[0]);
	qsort(arr, sz, sizeof(arr[0]), cmp_stu_by_name);
	int i = 0;
	for (i = 0; i < 3; i++)
	{
		printf("name = %s\tage = %d\n", arr[i].name, arr[i].age);
	}
}

int main()
{
	test1();
	test2();
	test3();
	return 0;
}

使用回调函数，模拟实现qsort（采用冒泡的方式）。

//交换
//因为我们不知道我们要交换的类型是什么，所以以最小字节来进行一一交换最合适不过
//我们还是需要知道这个类型的字节多少，所以传入了一个sz
void Swap(char* buf1, char* buf2, int sz)
{
	int i = 0;
	//我们知道字节大小的情况下，循环交换两数的每个字节
	for (i = 0; i < sz; i++)
	{
		char tmp = *(buf1 + i);
		*(buf1 + i) = *(buf2 + i);
		*(buf2 + i) = tmp;
	}
}

void Bubble_sort(const void* base, int num, int sz, int (*cmp)(const void*, const void*))
{
	int i = 0;
	for (i = 0; i < num - 1; i++)
	{
		int j = 0;
		for (j = 0; j < num - 1 - i; j++)
		{
		//通过我们自己写的比较函数来判断是否符合条件
			if ((*cmp)((char*)base + j * sz, (char*)base + (j + 1) * sz) > 0)
			{
				//交换
				Swap((char*)base + j * sz, (char*)base + (j + 1) * sz, sz);
			}
		}
	}
}

//定义结构体
typedef struct Stu Stu;
struct Stu
{
	char name[20];
	int age;
};

//结构体年龄成员比较方式
int cmp_stu_by_age(const void* p1, const void* p2)
{
	return (((Stu*)p1)->age - ((Stu*)p2)->age);
}

//结构体名字成员比较方式
int cmp_stu_by_name(const void* p1, const void* p2)
{
	return strcmp(((Stu*)p1)->name, ((Stu*)p2)->name);
}

//测试Bubble_sort 排序结构体数据
void test_2()
{
	Stu arr[3] = { {"XingC", 22}, {"qmx_07", 20}, {"Yuu", 21} };
	int sz = sizeof(arr) / sizeof(arr[0]);
	Bubble_sort(arr, sz, sizeof(arr[0]), cmp_stu_by_name);
	int i = 0;
	for (i = 0; i < sz; i++)
	{
		printf("name = %s\tage = %d\n", arr[i].name, arr[i].age);
	}
}

//整型比较方式
int cmp_int(const void* p1, const void* p2)
{
	return *(int*)p1 - *(int*)p2;
}

//测试Bubble_sort 排序整型数据
void test_1()
{
	int arr[10] = {5, 7, 2, 3, 9, 1, 6, 8, 4, 10};
	int sz = sizeof(arr) / sizeof(arr[0]);
	//cmp_int是函数名；实参传入函数名，形参接收函数的类型
	Bubble_sort(arr, sz, sizeof(arr[0]), cmp_int);
	int i = 0;
	for (i = 0; i < sz; i++)
	{
		printf("%d ", arr[i]);
	}
}

int main()
{
	/*test_1();*/
	test_2();
	return 0;
}

9. 指针和数组笔试题解析

总结：

1. sizeof(数组名)，这里的数组名表示整个数组，计算的是整个数组的大小。
2. &数组名，这里的数组名表示整个数组，取出的是整个数组的地址。
3. 除此之外所有的数组名都表示首元素的地址。

10. 指针笔试题

输出结果：

总结：

• 当我们能学到这里的时候，想必已经对指针了解的比较深入了，纵观整个指针的学习过程中，其实一直绕不开的就是指针类型，最重要的也就是指针类型，我们一直围绕的也就是指针类型。

• 其实指针就是一个指向或者是一个地址，当不需要进行任何操作的时候，就可以用void*替代，但涉及到任何运算以及解引用操作权限都需要指针类型。

• 当我们能彻底搞清楚我们指针的类型的时候，那么也就对解引用操作以及运算移动操作都将非常清晰，让我们在底层的访问中无往不利。

本章完~