C语言：指针（超深度讲解）

╰半橙微兮° 2023-10-14 22:39 6阅读 0赞

## ![0d6f678baad44096a4968d49e94b4e0c.png][] ##

**目录**

指针：

学习目标：

指针可以理解为：

字符指针：

定义：字符指针 char\*。

字符指针的使用：

练习：

指针数组：

概念：指针数组是一个存放指针的数组。

实现模拟二维数组：

数组指针：

概念：能够指向数组的指针。(可以理解为先与指针结合再与数组结合)

值得注意的是：

数组指针一般用于二维数组：数组的传参：

一维数组传参：

二维数组的传参：

总结:二维数组传参，函数形参的设计只能省略第一个\[ \]的数字因为对一个二维数组，可以不知道有多少行，但是必须知道一行多少元素这样才方便运算。

指针的传参：

一级指针传参：

二级指针的传参：

函数指针：

概念：指向函数的指针。

阅读两段有趣的代码：

类型重定义：typedef

函数指针数组：

定义：int (\*parr1\[10\])(); 每个元素都是函数指针类型。

用途：转移表。

函数指针数组的使用：

指向函数指针数组的指针：

定义：

指向函数指针数组的指针是一个 指针 指针指向一个 数组 ，数组的元素都是 函数指针 ; （一般不直接写，通过函数指针一步一步变化得到，可以减少失误操作）

回调函数：

概念：

使用回调函数模拟实现qsort()函数：

qsort()运用：

排序int类型：

排序结构体类型：

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

> ## **学习目标：** ##
> 
> **1. 字符指针** 
> 
> **2. 指针数组** 
> 
> **3. 数组指针**
> 
> **4. 数组传参和指针传参** 
> 
> **5. 函数指针** 
> 
> **6. 函数指针数组** 
> 
> **7. 指向函数指针数组的指针** 
> 
> **8. 回调函数**

## 指针： ##

### **指针可以理解为：** ###

![6673673da9ef4823b66ddcb309242a68.png][]

## **字符指针：** ##

###  定义：字符指针 char\*。 ###

### 字符指针的使用： ###

> **//使用1**
> 
> int  main () 
> 
> \{ 
> 
> char  ch  =  'w' ; 
> 
> char \* pc  = & ch ; 
> 
> \* pc  =  'w' ; 
> 
> return  0 ; 
> 
> \}
> 
> **//使用2**
> 
> int  main () 
> 
> \{ 
> 
> const  char\*  pstr  =  "hello bit." ;//把一个常量字符串的 首字符 h 的地址 存放到指针变量  pstr  中
> 
> printf ( "%s\\n" ,  pstr ); 
> 
> return  0 ; 
> 
> \}

### **练习：** ###

![a5b477bb6e98492ba8b87edceb0dab90.png][]

## **指针数组：** ##

###  概念：指针数组是一个存放指针的数组。 ###

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

### 实现模拟二维数组： ###

![50234e4bb2bd4c028d0776c054bd80fc.png][]

## **数组指针：** ##

### 概念：能够指向数组的指针。(可以理解为**先与指针结合再与数组结合)** ###

>  **int**  **(\*p)\[10\];** 
> 
> // 解释： **p先和\*结合，说明p是一个指针变量** ，然后指着指向的是一个大小为 10 个整型的数组。所以 p 是一个指针，指 向一个数组，叫数组指针。 
> 
> // 这里要注意： \[ \] 的优先级要高于 \* 号的，所以必须加上（）来保证 p 先和 \* 结合。

### 值得注意的是： ###

![a387ea3713304b7481e97680d85acf8c.png][]

![93b1d7f4d6214484a9a5b73297575109.png][]

> **数组名的理解:数组名是数组首元素的地址  
> 有2个例外：  
> 1. sizeof(数组名)，这里的数组名不是数组首元素的地址，数组名表示整个数组，sizeof(数组名)计算的是整个数组的大小，单位是字节  
> 2. &数组名，这里的数组名表示整个数组， &数组名取出的是整个数组的地址  
> 除此之外，所有的地方的数组名都是数组首元素的地址**

![5136489705b04c0c8f10c9e69957cb35.png][]

### 数组指针一般用于二维数组： ###

#### 数组的传参： ####

![ffade071e5c84b39bd1a22144e29b7bd.png][]

> 二维数组的**每一行可以理解为二维数组的一个元素**，**每一行又是一个一维数组**，所以二维数组其实是一维数组的数组。
> 
> 二维数组的数组名，也是数组名，数组名就是数组首元素的地址。
> 
> **arr----首元素的地址；**
> 
> **arr----第一行的地址；  
> arr----一维数组的地址即数组的地址。**

#### 一维数组传参： ####

![f91e780f439c44fb9a62ccaef969556e.png][]

#### **二维数组的传参：**  ####

![b45aa3479b324614a912cc4f52bfc2b0.png][]

> ##### **总结:**二维数组传参，函数形参的设计**只能省略第一个\[ \]**的数字因为对一个**二维数组**，**可以不知道有多少行，但是必须知道一行多少元素**这样才方便运算。 #####

#### 指针的传参： ####

##### 一级指针传参： #####

![f57b92a188144fb79aa55cd676a4a760.png][]

##### 二级指针的传参： #####

![29f18d5b29d5420b82ec4282846d113b.png][]

## 函数指针： ##

### 概念：指向函数的指针。 ###

>  **int (\*pf)(int, int)** = &Add;
> 
> //pf是函数指针变量  
> //int (\*)(int, int) 是函数指针类型

void test(char* pc, int arr[10])
    {
    
    }
    int main()
    {
    	void (*pf)(char *, int [10]) = test;
    
    	return 0;
    }

![87843e21a0ba47b2bb6b58ef9135dc48.png][]

> **由上图可知：** 
> 
> 函数名是函数的地址；
> 
>  &函数名也是函数的地址。

### **阅读两段有趣的代码：** ###

> **//代码1** 
> 
> ( \* ( void  ( \* )()) 0 )(); 
> 
> 解析：调用0地址处的函数  
> 1. 将0强制类型转换为void (\*)() 类型的函数指针  
> 2. 调用0地址处的这个函数
> 
> **//代码2** 
> 
> void  ( \* signal ( int  ,  void ( \* )( int )))( int );
> 
> 解析：
> 
>  1.signal 是一个函数声明  
> 2.signal 函数有2个参数，第一个参数的类型是int，第二个参数的类型是 void(\*)(int) 函数指针类型  
> 3.该函数指针指向的函数有一个int类型的参数，返回类型是void  
> 4.signal 函数的返回类型也是void(\*)(int) 函数指针类型,该函数指针指向的函数有一个int类型的参数，返回类型是void

### 类型重定义：typedef ###

//类型重定义1
    typedef unsigned int uint;
    typedef int* ptr_t;
    
    int main()
    {
    	uint u1;
    	ptr_t p1;
    	int* p2;
    	return 0;
    }
    
    //类型重定义2
    typedef int(*parr_t)[10];
    typedef int (*pf_t)(int, int) ;
    
    int main()
    {
    	typedef void(*pf_t)(int);
    	pf_t signal(int, pf_t);
        //上方两句将下方的语句简化，效果相同
    	void (* signal(int, void(*)(int) ) )(int);
    
    	return 0;
    }

## 函数指针数组： ##

### 定义：int (\*parr1\[10\])(); 每个元素都是函数指针类型。 ###

###  用途：转移表。 ###

### 函数指针数组的使用： ###

#include <stdio.h>
    #include <string.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");
    	printf("***************************\n");
    }
    //实现int类型的加减乘除
    int main()
    {
    	int input = 0;
    	int x = 0;
    	int y = 0;
    	int ret = 0;
    	//函数指针数组的使用 - 转移表
    	int (* pfArr[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 = pfArr[input](x, y);
    			printf("ret = %d\n", ret);
    		}
    		else if(input == 0)
    		{
    			printf("退出计算器\n");
    		}
    		else
    		{
    			printf("选择错误，重新选择\n");
    		}
    	} while (input);
    
    	return 0;
    }

## **指向函数指针数组的指针：** ##

### 定义： ###

####  指向函数指针数组的指针是一个 指针 指针指向一个 数组 ，数组的元素都是 函数指针 ; （一般不直接写，通过函数指针一步一步变化得到，可以减少失误操作） ####

> void (\*pf)(const char\*) = test; //pf是函数指针变量  
> void (\*pfArr\[10\])(const char\*); //pfArr是存放函数指针的数组  
> **void (\* (\*p) \[10\])(const char\*) = &pfArr;**//**p指向函数指针数组的指针**

### **回调函数：** ###

#### 概念： ####

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

> **//回调函数的使用**
> 
> 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);  
> \}

#### 使用回调函数模拟实现qsort()函数： ####

![e85b35f16b0f4cbca26dcef5336f4edb.png][]

**base:**指向要排序的数组的**第一个对象的指针**，转换为 .`void*。`

**num:**数组中由指向的**元素个数**。是无符号整型。

**size:**数组中**每个元素的大小（以字节为单位）**，是无符号整型。

**compar:**指向**比较两个元素的函数的指针**，重复调用此函数以比较两个元素。

##### qsort()运用： #####

#include <stdio.h>
    //qosrt函数的使用者得实现一个比较函数
    int int_cmp(const void * p1, const void * p2)
    {
     return (*( int *)p1 - *(int *) p2);
    }
    int main()
    {
     int arr[] = { 1, 3, 5, 7, 9, 2, 4, 6, 8, 0 };
     int i = 0;
     
     qsort(arr, sizeof(arr) / sizeof(arr[0]), sizeof (int), int_cmp);
     for (i = 0; i< sizeof(arr) / sizeof(arr[0]); i++)
     {
     printf( "%d ", arr[i]);
     }
     printf("\n");
     return 0;
    }

##### 排序int类型： #####

#include <stdio.h>
    
    //比较int类型的比较函数
    int my_compare(const void* q1, const void* q2)
    {
    	return (*(int*)q1 - *(int*)q2);
    }
    //交换每一个字节的元素
    void Swap(char* b1, char* b2, int size)
    {
    	int i = 0;
    	for (i = 0; i < size; i++)
    	{
    		char tmp = *b1;
    		*b1 = *b2;
    		*b2 = tmp;
    		b1++;
    		b2++;
    	}
    }
    //模拟实现自己的qsort()函数
    void my_qsort(void* base, int num, int size, int (*my_compare)(const void* q1, const void* q2))
    {
    	int i = 0;
    	int j = 0;
    	for (i = 0; i < num - 1; i++)
    	{
    		for (j = 0; j < num - 1 - i; j++)
    		{
    			//从小到大排序
    			if (my_compare((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] = { 2,4,6,7,8,3,1,0,9,5 };
    	int sz = sizeof(arr) / sizeof(arr[0]);
    	my_qsort(arr, sz, sizeof(arr[0]), my_compare);
    	return 0;
    }

##### 排序结构体类型： #####

#include <string.h>
    //创建学生结构体
    struct Stu
    {
    	char name[20];
    	int age;
    };
    //比较int类型的比较函数
    int my_compare_age(const void* q1, const void* q2)
    {
    	return ((struct Stu*)q1)->age - ((struct Stu*)q2)->age;
    }
    //比较int类型的比较函数
    int my_compare_name(const void* q1, const void* q2)
    {
    	return strcmp( ( (struct Stu*)q1 )->name ,( (struct Stu*)q2 )->name);
    }
    //交换每一个字节的元素
    void Swap(char* b1, char* b2, int size)
    {
    	int i = 0;
    	for (i = 0; i < size; i++)
    	{
    		char tmp = *b1;
    		*b1 = *b2;
    		*b2 = tmp;
    		b1++;
    		b2++;
    	}
    }
    //模拟实现自己的qsort()函数
    void my_qsort(void* base, int num, int size, int (*my_compare)(const void* q1, const void* q2))
    {
    	int i = 0;
    	int j = 0;
    	//趟数
    	for (i = 0; i < num - 1; i++)
    	{
    		//一趟内部比较的对数
    		for (j = 0; j < num - 1 - i; j++)
    		{
    			//从小到大排序
    			if (my_compare((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 arr[] = { {"zhangsan",34},{"lisi",27},{"wanwu",20} };
    	int sz = sizeof(arr) / sizeof(arr[0]);
    	my_qsort(arr, sz, sizeof(arr[0]), my_compare_age);
    	my_qsort(arr, sz, sizeof(arr[0]), my_compare_name);
    	return 0;
    }

## 以上就是个人学习指针的个人见解和学习的解析，欢迎各位大佬在评论区探讨！ ##

## 感谢大佬们的一键三连！ 感谢大佬们的一键三连！ 感谢大佬们的一键三连！ ##

![7bad9f1ed1b44b53b34d043644d9965a.png][]

[0d6f678baad44096a4968d49e94b4e0c.png]: https://img-blog.csdnimg.cn/0d6f678baad44096a4968d49e94b4e0c.png
[6673673da9ef4823b66ddcb309242a68.png]: https://img-blog.csdnimg.cn/6673673da9ef4823b66ddcb309242a68.png
[a5b477bb6e98492ba8b87edceb0dab90.png]: https://img-blog.csdnimg.cn/a5b477bb6e98492ba8b87edceb0dab90.png
[50234e4bb2bd4c028d0776c054bd80fc.png]: https://img-blog.csdnimg.cn/50234e4bb2bd4c028d0776c054bd80fc.png
[a387ea3713304b7481e97680d85acf8c.png]: https://img-blog.csdnimg.cn/a387ea3713304b7481e97680d85acf8c.png
[93b1d7f4d6214484a9a5b73297575109.png]: https://img-blog.csdnimg.cn/93b1d7f4d6214484a9a5b73297575109.png
[5136489705b04c0c8f10c9e69957cb35.png]: https://img-blog.csdnimg.cn/5136489705b04c0c8f10c9e69957cb35.png
[ffade071e5c84b39bd1a22144e29b7bd.png]: https://img-blog.csdnimg.cn/ffade071e5c84b39bd1a22144e29b7bd.png
[f91e780f439c44fb9a62ccaef969556e.png]: https://img-blog.csdnimg.cn/f91e780f439c44fb9a62ccaef969556e.png
[b45aa3479b324614a912cc4f52bfc2b0.png]: https://img-blog.csdnimg.cn/b45aa3479b324614a912cc4f52bfc2b0.png
[f57b92a188144fb79aa55cd676a4a760.png]: https://img-blog.csdnimg.cn/f57b92a188144fb79aa55cd676a4a760.png
[29f18d5b29d5420b82ec4282846d113b.png]: https://img-blog.csdnimg.cn/29f18d5b29d5420b82ec4282846d113b.png
[87843e21a0ba47b2bb6b58ef9135dc48.png]: https://img-blog.csdnimg.cn/87843e21a0ba47b2bb6b58ef9135dc48.png
[e85b35f16b0f4cbca26dcef5336f4edb.png]: https://img-blog.csdnimg.cn/e85b35f16b0f4cbca26dcef5336f4edb.png
[7bad9f1ed1b44b53b34d043644d9965a.png]: https://img-blog.csdnimg.cn/7bad9f1ed1b44b53b34d043644d9965a.png