【零天赋C语言】——详解指针（保姆级教学）

前言：在之前的初识指针中我们知道了指针的概念：

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

今天我们来深入学习指针的进阶。

---

一、字符指针

字符指针即指的是：char*

一般使用如下：

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

但是当我们以如下方式使用时：

这里的parr存放的是整个字符串吗？

打印出*parr可得：

所以上面的做法的意思是把字符串的首字符的地址存放在字符指针变量parr中。

但是当我们修改* parr的值时，是不可取的，因为不能修改常量字符串，要加以const修饰

二、指针数组

指针数组顾名思义，是一个用来存放指针的数组。

例如：

 

 三、数组指针

3. 1数组指针的定义

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

答案是：指针。

由以上两点，我们知道:

整形指针： int * pint; 能够指向整形数据的指针。
浮点型指针： float * pf; 能够指向浮点型数据的指针。
那数组指针应该是：能够指向数组的指针。

例如：

int (*p) [10]

解释：p 先和 * 结合，说明 p 是一个指针变量，然后指向的是一个大小为10个整形的数组，所以 p 是一个指针，指向一个数组，叫数组指针。

注：* 和 p 要优先结合，写成（* p）。

3. 2  &数组名 VS 数组名

对于下面的数组：

 由之前的知识我们可以知道：数组名 arr 表示首元素的地址。

那 &arr 呢？

我们思考下列代码：

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

运行结果 ：

解析：虽然 arr 和 &arr 打印的地址结果相同，但是 arr + 1 跳过的是四个字节，&arr + 1 跳过的是一个数组四十个字节，所以 arr 表示的是数组首元素的地址，&arr  表示的是整个数组的地址。

本例题中的 &arr 的类型是：int （* p），一种数组指针类型。

3. 3  数组指针的使用

数组指针是指针，其存储的是数组的地址。

通过下面代码来理解数组指针：

#include 
void print_arr1(int arr[3][5], 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");
	}
}
void print_arr2(int(*arr)[5], 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("%d ", *(*(arr + i) + j));
		}
		printf("\n");
	}
}
int main()
{
	int arr[3][5] = { 1,2,3,4,5,6,7,8,9,10 };
	print_arr1(arr, 3, 5);

	print_arr2(arr, 3, 5);
	return 0;
}

运行结果：

解析：数组名arr，表示首元素的地址，但是二维数组的首元素是二维数组的第一行，所以这里传递的arr，其实相当于第一行的地址，是一维数组的地址可以数组指针来接收，*（arr + i ） 找到是第 i 行的数组，* (*（arr + i ）+ j ) 就可以得到第 i 行数组的元素。

四、数组参数、指针参数

4. 1 一维数组传参

#include 
void test(int arr[])//ok?
{}
//数组名作为参数传参，当然可以用数组来接收，不用标明数组的大小，因为用数组接收的本质是接收它的地址。——√
void test(int arr[10])//ok?
{}
//数组名作为参数传参，当然可以用数组来接收，标明数组的大小对其不影响，因为用数组接收的本质是接收它的地址。——√
void test(int* arr)//ok?
{}
//数组名作为参数传参，传过来的是数组首元素的地址，当然可以用相同类型的指针来接收。——√
void test2(int* arr[20])//ok?
{}
//test2 的参数是arr2数组 ，是一个指针数组，当然可以用相同类型的指针数组来接收。 ——√
void test2(int** arr)//ok?
{}
// 因为arr2 数组名表示的是首元素的地址，而其地址又是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？
{}
//二维数组数组名作为参数传参，可以用一个二维数组作为形参来接收,但是行可以省略，列不可以省略所以是错的——X
void test(int arr[][5])//ok？
{}
//二维数组数组名作为参数传参，所以可以用一个二维数组作为形参来接收，行可以省略，列不能省略——√
void test(int* arr)//ok？
{}
//明显不是一级指针，所以是错的。——X
void test(int* arr[5])//ok？
{}
//二维数组的数组名是第一行的地址，不能用数组作为形参来接收，所以是错的。——X
void test(int(*arr)[5])//ok？
{}
//二维数组的数组名传参，可以用数组指针作为形参来接收每个数组有五个元素。——√
void test(int** arr)//ok？
{}
//二级指针接收明显是错的。——X
int main()
{
	int arr[3][5] = { 0 };
	test(arr);
}

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

 五、函数指针

函数指针：指针指向函数的指针。

思考下列代码：

下面pfun1和pfun2哪个有能力存放test函数的地址？

void test()
{
   printf("hehe\n");
}

void (*pfun1)();
void *pfun2();

 解析：pfun1可以存放。pfun1先和*结合，说明pfun1是指针，指针指向的是一个函数，指向的函数无参数，返回值类型为void。

六、函数指针数组

把函数的地址存到一个数组中，那这个数组就叫做函数指针数组，其定义如下：

int （* parr [10]）();

 parr1 先和 [] 结合，说明 parr1是数组，是 int (*)() 类型的函数指针。

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

#include 
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;
	int(*p[5])(int x, int y) = { 0, add, sub, mul, div }; //转移表
	while (input)
	{
		printf("*************************\n");
		printf(" 1:add 2:sub \n");
		printf(" 3:mul 4:div \n");
		printf("*************************\n");
		printf("请选择：");
		scanf("%d", &input);
		if ((input <= 4 && input >= 1))
		{
			printf("输入操作数：");
			scanf("%d %d", &x, &y);
			ret = (*p[input])(x, y);
		}
		else
			printf("输入有误\n");
		printf("ret = %d\n", ret);
	}
	return 0;
}

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

指向函数指针数组的指针是一个指针

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

定义如下：

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

int main()
{
    //函数指针pfun
    void (* pfun)( const char* ) = test;
    
    //函数指针的数组pfunarr
    void (*pfunarr [5]) (const char *str); 
    //pfunarr[0] = test;
    
    //指向函数指针数组pfunarr 的指针ppfunarr
    void (* (*ppfunarr)[5])(const char *) = &pfunarr;
    return 0;
}

 八、回调函数

定义：

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

 

 使用举例：

#include 
#include 

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

 模拟实现qsort函数：

#include
#include

int cmp(const void* e1, const void* e2) //根据自己排序的类型进行设定
{
	return *((int*) e1) - *((int*)e2);
}

void swap(char* buff1, char* buff2, int width)
{
	int i = 0;
	for (i = 0; i < width; i++)
	{
		int tmp = *buff1;
		*buff1 = *buff2;
		*buff2 = tmp;
		buff1++;
		buff2--;
	}
}

void my_qsort(void* base, int sz, int width, int (*cmp) (const void* e1 , const void* e2))
{
	int i = 0;
	int j = 0;
	for (i = 0; i < sz -1; i++)
	{
		for (j = 0; j < sz - 1 - i; j++)
		{
			//比较
			if (strcmp((char*)base + j * width, (char*)base + (j + 1) * width) > 0)
			{
				//交换
				swap((char*)base + j * width, (char*)base + (j + 1) * width, width);
			}
		}
	}
}
int main()
{
	int arr[] = { 2, 0,1,4,3,5,7,8,6,9 };
	int sz = sizeof(arr) / sizeof(arr[0]);
	my_qsort(arr, sz, sizeof(arr[0]), cmp);
	int i = 0;
	for (i = 0; i < sz; i++)
	{
		printf("%d ", arr[i]);
	}
	return 0;
}