【C语言】指针的进阶

骑猪看日落 2023-10-14 19:37 14阅读 0赞

**目录**

一、字符指针

二、指针数组

三、数组指针

1.数组指针的定义

2.&数组名和数组名区别

3.数组指针的使用

四、数组参数与指针参数

1.一维数组传参

2.二维数组传参

3.一级指针传参

4.二级指针传参

五、函数指针

六、函数指针数组

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

八、回调函数

1.回调函数 模拟 qsort函数

--------------------

> 在之前初阶指针中，我们已经接触到了
> 
> 1.  指针就是变量，用来存放地址的变量，地址可以标识一个内存空间
> 2.  指针是有类型的，指针的类型决定了指针 +- 整数的步长，以及指针解引用时权限
> 3.  指针的大小是固定的4/8字节（32位/64位平台）
> 4.  指针的运算
> 
> [链接：][Link 1][初阶指针][Link 1]

接下来是指针的进阶

## 一、字符指针 ##

**1.**

在指针的类型中有一个是 char \*

//操作一个字符
    #include<stdio.h>
    int main() 
    {
    	char ch = 'x';
    	char* pc = &ch;
    	*pc = "a";
    	return 0;
    }

//操作字符串
    #include<stdio.h>
    int main()
    {
    	const char* str = "abcdef";
    	printf("%s",str);
    	return 0;
    }

**注意：**上述的代码 const char\* str = "abcdef"; 我们平时可能认为 把字符串放到 str 里面了，但是本质上是把首字符的地址放到str里面。如下图

![4923fc3f84e743388d6988fc158883e5.png][]

就是把 字符串中的首字符 a 的地址 0x1122334 存到指针变量 str 中

**2.**

**【例】判断输出结果**

//数组与字符指针的指向问题
    #include<stdio.h>
    int main()
    {
    	char arr1[] = "abcdef";
    	char arr2[] = "abcdef";
    	const char* str1 = "abcdef";
    	const char* str2 = "abcdef";
    
    	if (arr1 == arr2)
    		printf("arr1 and arr2 are same\n");
    	else
    		printf("arr1 and arr2 are not same\n");
    
    	if (str1 == str2)
    		printf("str1 and str2 are same\n");
    	else
    		printf("str1 and str2 are not same\n");
    
    	return 0;
    }

【结果】

![d127bbbd65ae4b17a3ba9895717a5797.png][]

**解析：** 数组名 一般情况是 数组首元素的地址，arr1与arr2是两个不同的数组名，虽然存放这相同的常量字符串，arr1 与 arr2 是指向不同的内存块，只是这两个内存放着相同内容。

而 str1 与 str2 是 指向的是 同一个常量字符串，指向的是同一块内存，str1 和 str2 相同

## 二、指针数组 ##

**指针数组 是 存放指针的 数组（数组中的每一个元素都是指针）**

![41466508217e42daad89c20964f35d99.png][]

**指针数组的使用**

**（1）**

//指针数组的使用
    #include<stdio.h>
    int main()
    {
    	char* str0 = "abc";
    	char* str1 = "aaa";
    	char* str2 = "bbb";
    	char* arr[] = {str0,str1,str2};
    	printf("%s\n%s\n%s\n",arr[0],arr[1],arr[2]);
    	return 0;
    }

**（2）使用指针数组模拟一个二维数组**

//指针数组模拟二维数组
    #include<stdio.h>
    int main()
    {
    	int arr1[3] = {1,2,3};
    	int arr2[3] = {4,5,6};
    	int arr3[3] = {7,8,9};
    	int* arr[3] = {arr1,arr2,arr3};
    	int i = 0;
    	for (i = 0; i < 3;i++)
    	{
    		int j = 0;
    		for (j = 0; j < 3;j++)
    		{
    			printf("%d ",arr[i][j]);
    		}
    		printf("\n");	
    	}
    	return 0;
    }

## 三、数组指针 ##

**数组指针是指向数组的指针**

我们在前面已经了解到

整型指针 （int \* a;）指向整型数据的指针

浮点型指针（float \* pf;）指向浮点型数据的指针

**那么数组指针 就是 能够指向数组(型)数据的指针**

### 1.数组指针的定义 ###

int (*p) [10];

![cc0caeb9756b47dbbbdac82cb0d5ee74.png][]

**注意: \[ \]的优先级 高于 \* ，所以 要加上（）来保证p 先和 \* 结合**

### 2.&数组名和数组名区别 ###

经过前面数组的学习 我们了解到 &arr 与 arr 所打印的值 一样的，但是 意义不一样

回想一下

arr 是数组首元素的地址

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

**&arr的类型是 int (\*) \[10\],是一种** **数组指针** **的类型**

arr+1 跳过的是数组元素大小，而 &arr + 1 与 &arr 的 差值是 一个数组的大小

### 3.数组指针的使用 ###

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

//数组指针的使用
    #include<stdio.h>
    int main() 
    {
    	int arr[10] = {1,2,3,4,5,6,7,8,9,10};
    	int(*pa)[10] = &arr;//把数组arr的地址赋值给数组指针变量pa
    	//上述其实我们一般很少这样写
    	return 0;
    }

数组指针的使用

#include<stdio.h>
    void Print_arr(int (*arr)[3] ,int row,int col) 
    {
    	int i = 0;
    	for (i = 0; i < row;i++)
    	{
    		int j = 0;
    		for (j = 0; j < col;j++) 
    		{
    			printf("%d ",arr[i][j]);
    		}
    		printf("\n");
    	}
    }
    int main() 
    {
    	int arr[3][3] = {1,1,1,2,2,2,3,3,3};
    	Print_arr(arr,3,3);
    	//数组名arr，表示首元素的地址
    	//但是二维数组的首元素是二维数组的第一行
    	//所以这里传递的arr，其实相当于第一行的地址，是一维数组的地址
    	//可以数组指针来接收
    	return 0;
    }

**【练习】**看看下方代码的意思

int arr[5];
    int *parr1[10];
    int (*parr2)[10];
    int (*parr3[10])[5];

【结果】

1.  存放 5个 整型元素的数组
2.  存放10个整型指针元素的数组
3.  指向 一个存放10个整型元素的 数组的指针
4.  parr3\[10\]是一个数组， 一个存放 10个数组指针元素的 数组, 每一个元素的类型是 数组指针 (数组指针，指向的数组有 5个元素 ，每一个元素的类型是int )

## 四、数组参数与指针参数 ##

数组传参：参数可以写完为数组的形式

### 1.一维数组传参 ###

void test(int arr[])
    {}
    void test(int arr[10])
    {}
    void test(int* arr)
    {}
    void test2(int* arr[20])
    {}
    void test2(int** arr)
    {}

### 2.二维数组传参 ###

二维数组传参写成数组的形式的时候 int arr\[ \] \[ 3\],可以不知道有多少行，但是必须知道一行有多少元素

void test(int arr[3][5])
    {}
    
    void test(int arr[][5])
    {}
    
    void test(int(*arr)[5])
    {}

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

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

## 五、函数指针 ##

> &函数名 是函数的地址
> 
> 函数名 也是函数的地址

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

【结果】![2a17821ba70f4678aaf237b1a32f9501.png][]

**函数指针的定义**

void (*test) ();

**test先和\*结合，说明test是指针，指针指向的是一个函数，指向的函数无参  
数，返回值类型为void**

【练习】分析下方代码

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

**代码1**

是 调用0地址处的函数，这个函数没有参数，返回类型为void

![55b1b45a26d54ba3b4ff1cb147cedbf2.png][]

**代码2**

是 一次函数声明 ，声明的是signal 函数，signal函数的参数有两个，一个是int 类型,一个是void(\*)(int)类型，该类型，函数指针类型 ，指向的函数参数是int ,返回类型是 void

signal函数的返回类型也是函数指针类型，void(\* ) (int),该类型，函数指针类型 ，指向的函数参数是int ,返回类型是 void

## 六、函数指针数组 ##

**函数指针数组**：是**数组**，数组的每一个元素是函数指针类型

int (* parr[10])();

![047cf560c40146daa4422741ca35269a.png][]

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

接下来 我们先简单地写一个 两个正整数 进行加减乘除的 小程序， 见下方代码

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

![fdbd2176ea1c41c89f927a50e0fb7673.png][]

分析 一下上述代码 我们发现在 switch 语句中 大量出现输入输出 的 代码冗余

因为用到多个函数，其实 我们可以使**用函数指针数组** 来进行 **代码的大幅度简化**

#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 input = 0;
    	int x = 0;
    	int y = 0;
    	int ret = 0;
    	//用函数指针数组来存放
    	int (*parr[5])(int, int) = {NULL,add,sub,mul,div};//转移表 
    	//							 0    1   2   3   4
    	do {
    		menu();
    		printf("请选择：>");
    		scanf("%d", &input);
    		if (input >=1&&input<=4) 
    		{
    			printf("请输入操作数:>");
    			scanf("%d %d",&x,&y);
    			ret = parr[input](x,y);
    			printf("ret = %d\n",ret);
    		}
    		else if (input == 0) 
    			printf("退出计算器\n");
    		else
    			printf("输入错误，请重新输入\n");
    		}
    	 while(input);
    	return 0;
    }

![ce98f1029c7c475a88dfb879e23ed086.png][]

当然函数指针数组并不仅仅是转移表，函数指针数组在具体项目中起到的作用还是很多。

## 七、指向函数指针数组的指针 ##

函数指针数组 的指针 ： 是**指针**

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

指向 函数指针数组 的指针 ，感觉很绕口 有点像套娃

![俄罗斯套娃(5层) 民族手工艺品 旅游工艺品礼品-阿里巴巴][5_ _ _-]

**那 再看这个** **存放 指向 函数指针数组 的 指针 的数组**

![0528948384ca431ea3d6e236ef9771d0.png][]

指向函数指针数组的指针

int(* (*p)[4])(int,int);

![4d53a25fe06f49aaa97fd7a8044e6371.png][]

**正确的写法**

![5ed16b9b1a164f2cad59a5ccafa1e58f.png][]

## 八、回调函数 ##

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

接着引用上述 计算器的例子 使用回调函数

#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;
    }
    void calcu(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:
    			calcu(add);
    			break;
    		case 2:
    			calcu(sub);
    			break;
    		case 3:
    			calcu(mul);
    			break;
    		case 4:
    			calcu(div);
    			break;
    		case 0:
    			printf("退出计算器\n");
    			break;
    		default:
    			printf("输入错误，请重新输入\n");
    			break;
    		}
    	} while (input);
    	return 0;
    }

![c36f776651134ed18369f3f395023ba8.png][]

### 1.回调函数 模拟 qsort函数 ###

首先我们先了解一下 qsort 函数

**qsort 函数 ：快速排序，适合于任意元素类型，qsort 默认为升序**

作用 **Sort elements of array** 对数组元素进行排序

Sorts the num elements of the array pointed to by base, each element size bytes long, using the compar function to determine the order

将数组中指向的num个元素按基数(每个元素的长度为字节)排序，使用compar函数确定顺序

void qsort (void* base, size_t num, size_t size,int (*compar)(const void*,const void*));

看下图

![23f504fbe93c4f3ebca20e0f4bebb5b8.png][]

*我们平时排序（升序或者降序）可能会想到冒泡排序，当然冒泡排序也是可以的，但是冒泡排序所排序的元素还是 有一定限制的，如果排字符串，排结构体呢，显然冒泡排序是不合适的，那木这时 **qsort 函数是可以胜任的***

**【练习】使用qsort 进行排序**

#include<stdio.h>
    #include<stdlib.h>
    int int_cpm(const void*p1,const void *p2) 
    {
    	return (*(int*)p1 - *(int*)p2);
    }
    int main() 
    {
    	int arr[] = {2,1,4,3,5,6,9,7,8,10};
    	int num = sizeof(arr) / sizeof(arr[0]);
    	int i = 0;
    	qsort(arr,num,sizeof(int),int_cpm);
    	for (i = 0; i < num;i++)
    	{
    		printf("%d ",arr[i]);
    	}
    	return 0;
    }

![73d81737c6b34e55b693b87688d72687.png][]

在上述代码中 ，出现了 void \*

那先介绍一下 **void \* 的作用**， 然后再分析代码

> **void \* 指针**
> 
>  *  这是无具体类型的指针
>  *  可以接收任意类型的地址
>  *  这种类型的指针是**不直接解引用操作的，也不能直接进行指针运算**

![ab02d2eb1b1345d78a87feafe51ae3f0.png][]

有了前面的 qsort 函数的了解，**模拟实现qsort函数**

#include<stdio.h>
    #include<stdlib.h>
    int int_cpm(const void* p1, const void* p2)//比较函数
    {
    	return (*(int*)p1 - *(int*)p2);
    }
    void Swap(void*p1,void*p2,int size) 
    {
    	int i = 0;
    	for (i = 0; i < size;i++)
    	{
    		char tmp = *((char*)p1 + i);//一个一个字节进行交换
    		*((char*)p1 + i) = *((char*)p2 + i);
    		*((char*)p2 + i) = tmp;
    	}
    }
    void my_qsort(void*base,int num,int size,int(*cmp)(void*,void*)) 
    {
    	int i = 0;
    	int j = 0;
    	for (i = 0; i < num - 1;i++)
    	{
    		for (j = 0;j<num-1-i;j++)
    		{
    			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[] = { 2,1,4,3,5,6,9,7,8,10 };
    	int num = sizeof(arr) / sizeof(arr[0]);
    	int i = 0;
    	my_qsort(arr, num, sizeof(int), int_cpm);
    	for (i = 0; i < num; i++)
    	{
    		printf("%d ", arr[i]);
    	}
    	return 0;
    }

![bbd39cb35007422fb291a9de636c0d4a.png][]

这里解释一下核心 交换字节 的原因

要想保证 交换任意元素类型 ，使用int ?使用float？ 这些是不行的

![eae20c5285a74d5a9e2be19359a8bc96.png][]

这样的字节交换就保证 可以是任意类型元素进行交换

【练习】对 结构体里面的成员的名字进行 排序

struct Stu s1\[\] = \{ \{"zhangsan",28\},\{"wanwu",25\},\{"John",18\}\};

#include<stdio.h>
    #include<string.h>
    struct Stu 
    {
    	char name[20];
    	int age;
    };
    int cmp_name(const void* p1,const void* p2) 
    {
    	return strcmp(((struct Stu*)p1)->name,((struct Stu*)p2)->name);//比较字符串大小
    }
    void Swap(char *p1,char*p2,int size) //因为字符串 ，一个一个字符交换（正好字符char 是一个字节）
    {
    	//字节单元交换
    	int i = 0;
    	char tmp = 0;
    	for (i = 0; i < size;i++) 
    	{
    		tmp = *p1;
    		*p1 =* p2;
    		*p2 = tmp;
    		p1++;
    		p2++;		
    	}
    }
    void my_qsort(void *base,int num ,int size,int (*cmp)(const void*,const void*))
    {
    	int i = 0;
    	int j = 0;
    	for (i = 0; i < num - 1;i++)
    	{
    		for (j = 0; j < num - 1 - i;j++)
    		{
    			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() 
    {
    	struct Stu s1[] = {
       {"zhangsan",28},{"wanwu",25},{"John",18}};
    	int num = sizeof(s1) / sizeof(s1[0]);
    	my_qsort(s1,num,sizeof(struct Stu),cmp_name);
    	for (int i = 0; i < num;i++)
    	{
    		printf("%s\n",s1[i]);
    	}
    	return 0;
    }

[Link 1]: http://t.csdn.cn/k9ciL
[4923fc3f84e743388d6988fc158883e5.png]: https://img-blog.csdnimg.cn/4923fc3f84e743388d6988fc158883e5.png
[d127bbbd65ae4b17a3ba9895717a5797.png]: https://img-blog.csdnimg.cn/d127bbbd65ae4b17a3ba9895717a5797.png
[41466508217e42daad89c20964f35d99.png]: https://img-blog.csdnimg.cn/41466508217e42daad89c20964f35d99.png
[cc0caeb9756b47dbbbdac82cb0d5ee74.png]: https://img-blog.csdnimg.cn/cc0caeb9756b47dbbbdac82cb0d5ee74.png
[2a17821ba70f4678aaf237b1a32f9501.png]: https://img-blog.csdnimg.cn/2a17821ba70f4678aaf237b1a32f9501.png
[55b1b45a26d54ba3b4ff1cb147cedbf2.png]: https://img-blog.csdnimg.cn/55b1b45a26d54ba3b4ff1cb147cedbf2.png
[047cf560c40146daa4422741ca35269a.png]: https://img-blog.csdnimg.cn/047cf560c40146daa4422741ca35269a.png
[fdbd2176ea1c41c89f927a50e0fb7673.png]: https://img-blog.csdnimg.cn/fdbd2176ea1c41c89f927a50e0fb7673.png
[ce98f1029c7c475a88dfb879e23ed086.png]: https://img-blog.csdnimg.cn/ce98f1029c7c475a88dfb879e23ed086.png
[5_ _ _-]: https://img-blog.csdnimg.cn/img_convert/1db055ffe94fe06d1f394d1d9521d021.gif
[0528948384ca431ea3d6e236ef9771d0.png]: https://img-blog.csdnimg.cn/0528948384ca431ea3d6e236ef9771d0.png
[4d53a25fe06f49aaa97fd7a8044e6371.png]: https://img-blog.csdnimg.cn/4d53a25fe06f49aaa97fd7a8044e6371.png
[5ed16b9b1a164f2cad59a5ccafa1e58f.png]: https://img-blog.csdnimg.cn/5ed16b9b1a164f2cad59a5ccafa1e58f.png
[c36f776651134ed18369f3f395023ba8.png]: https://img-blog.csdnimg.cn/c36f776651134ed18369f3f395023ba8.png
[23f504fbe93c4f3ebca20e0f4bebb5b8.png]: https://img-blog.csdnimg.cn/23f504fbe93c4f3ebca20e0f4bebb5b8.png
[73d81737c6b34e55b693b87688d72687.png]: https://img-blog.csdnimg.cn/73d81737c6b34e55b693b87688d72687.png
[ab02d2eb1b1345d78a87feafe51ae3f0.png]: https://img-blog.csdnimg.cn/ab02d2eb1b1345d78a87feafe51ae3f0.png
[bbd39cb35007422fb291a9de636c0d4a.png]: https://img-blog.csdnimg.cn/bbd39cb35007422fb291a9de636c0d4a.png
[eae20c5285a74d5a9e2be19359a8bc96.png]: https://img-blog.csdnimg.cn/eae20c5285a74d5a9e2be19359a8bc96.png