一篇文章将你的指针升华

Posted 2021-07-25 吞吞吐吐鸭

文章目录

• • 1. 字符指针
  • • 定义
    • 用法
  • 2. 指针数组
  • • 定义
    • 用法
  • 3. 数组指针
  • • 定义
    • 补充
    • 注意
    • 用法
  • 4. 数组传参和指针传参
  • • 一维数组
    • 二维数组
    • 一级指针
    • 二级指针
    • 小结
  • 5. 函数指针
  • • 定义
    • 用法
    • 注意
    • 练习
    • 小结
  • 6. 函数指针数组
  • • 定义
    • 用法
  • 7. 指向函数指针数组的指针
  • • 定义
    • 用法
  • 8. 回调函数
  • • 定义
    • 用法
    • 补充（qsort函数）
  • 9.总结

指针的一些基础知识我已经在 【初阶指针】这章总结过了，如果大家有些地方不清楚，可以点击链接回过去看一下。【初阶指针】了解后，我们了解了指针的概念：

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

而这章我们将更深入的探索指针的其他奥秘。

1. 字符指针

定义

字符指针是指向字符的指针，char*

用法

字符指针通有两种用法：

用法一：指针指向一个字符

#include <stdio.h>
int main()
{
	char ch = 'a';
	char* pc = &ch;
	*pc = 'm';
	return 0;
}

用法二：指针指向一个字符串

指针存入的是字符串首字符的地址

#include <stdio.h>
int main()
{
	char* pc = "hello world!";//将字符串首字符'h'地址放入pc

	printf("%c\\n", *pc);//结果为：h
	printf("%s\\n", pc);//结果为：hello world!
	return 0;
}

接下来看一个练习：

#include <stdio.h>
int main()
{
	char str1[] = "hello world!";
	char str2[] = "hello world!";
	const char* str3 = "hello world!";
	const char* str4 = "hello world!";

	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;
}
//结果为：
//str1 and str2 are not same
//str3 and str4 are same

2. 指针数组

定义

• 指针数组，本质还是数组
• 数组其实已经有整型数组，字符数组，而指针数组也是一样的，是存放指针的数组

int arr[10];//整型数组——存放整型的数组
char ch[5];//字符数组——存放字符的数组

//指针数组——存放指针的数组
int* parr[5];//整型指针数组，有五个元素，每个元素是一个整形指针

用法

用法一：

#include <stdio.h>
int main()
{
	int a = 10;
	int b = 20;
	int c = 30;
	int* arr[3] = { &a, &b, &c };
	int i = 0;
	for (i = 0; i < 3; i++)
	{
		printf("%d ", *arr[i]);
	}
	return 0;
}

不推荐上面使用的方法，毕竟是多此一举啦

用法二：

#include <stdio.h>
int main()
{
	int a[5] = { 1,2,3,4,5 };
	int b[5] = { 2,3,4,5,6 };
	int c[5] = { 3,4,5,6,7 };
	int* arr[3] = { a,b,c };
	int i = 0;
	for (i = 0; i < 3; i++)
	{
		int j = 0;
		for (j = 0; j < 5; j++)
		{
			printf("%d ", *(arr[i] + j));
		}
		printf("\\n");
	}
	return 0;
}

• 输出函数也可以写成：printf("%d ", arr[i] [j]);
• 如果不知道推导的可以去看看初阶指针这章，在数组和地址的关系那部分有进行讲解

3. 数组指针

定义

数组指针，本质是指针，是指向数组的指针

补充

• 一维数组arr的地址是：&arr，如果+1跳过的是整个数组大小
• 一维数组名arr一般是数组首元素的地址，等价于&arr[0]，如果+1，跳过的是一个元素的大小
• 二维数组数组名表示首元素地址，而二维数组首元素实则是第一行，并非第一个元素

#include <stdio.h>
int main()
{
	int arr[5] = { 1,2,3,4,5 };
	int (*parr)[5] = &arr;
	return 0;
}

而如果将代码改成：int *parr[5] = &arr; 表示的还是数组指针吗？NO！

• 因为[]的优先级要高于 * 号，所以必须加上（）来保证parr先和 * 结合，只有 * 和parr结合才能说明parr是一个指针。
• 而若不加*，parr[5]结合，表示的是一个数组，故这里就是指针数组而不是数组指针

练习：将指向double* a[5];的指针写出来

double* (*pa)[5];

因为a[5]是一个数组，每个元素都是double*类型，故是一个指针数组。指针为( *pa )，而它指向的是一个数组( *pa )[5]，而每个元素都是double * 类型的，故结果为：double* (*pa)[5];

注意

数组名一般是数组首元素的地址，但有两种情况例外：

1. sizeof(数组名)——数组名表示整个数组，计算的是整个数组大小，单位是字节
2. &数组名——数组名表示整个数组，取出的是整个数组的地址

用法

练习一：用一维数组数组地址输出元素值（平常一般不使用这种方法）

#include <stdio.h>
int main()
{
	int arr[5] = { 1,2,3,4,5 };
	int(*pi)[5] = &arr;
	int i = 0;
	for (i = 0; i < 5; i++)
	{
		printf("%d ", *(*pi+i));
	}

	return 0;
}

我们可以知道*pi其实就是数组名，而数组名表示了数组首元素的地址，（ *pi+i ）则表示数组每个元素的地址，再通过解引用就是每个元素的值

练习二：写一个函数接收二维数组地址输出元素值

void print2(int(*p)[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 ", *(*(p + 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} };
	print2(arr, 3, 5);
	return 0;
}

练习三：判断int(*parr[10])[5];的parr是什么？

parr是一个存放数组指针的数组。该数组能存放十个数组指针。每个数组指针能够指向一个数组，该数组有五个元素，每个元素是int类型

4. 数组传参和指针传参

在写代码时你是否经常碰到将【数组】或者【指针】传给函数，那么函数的参数该怎么设计呢？下面分别取一维数组、二维数组、一级指针、二级指针传给函，梳理出一些正确以及错误的方式

一维数组

#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);
	return 0;
}

为什么test2的第二种可以呢？首先我们要知道指针数组他的每个元素都是一个指针，而数组名是数组首元素的地址，故传过去的就是第一个指针的地址，而二级指针可以存放指针的地址

二维数组

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);
    return 0;
}

• 因为二维数组数组名表示数组第一行的地址，如果单纯用整型指针接收，那么该指针接收到的是个有五个元素数组的地址，而不是首元素的地址。如果用数组指针接收，该指针指指向的就是一个有五个整型元素的的数组，而传过来的就是一个有五个元素数组的地址，刚好存入。
• 二级指针的话接受的应该是一级指针的地址，而二维数组传过去的是第一行数组的地址，两者不一样

一级指针

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

二级指针

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

小结

函数形参为一级指针，可以接收哪些参数：

1. 元素的地址
2. 一级指针

函数形参为二级指针，可以接收哪些参数：

1. 二级指针
2. 一级指针变量地址
3. 存放一级指针的数组

5. 函数指针

定义

函数指针是指向函数的指针，存放函数地址的指针

用法

首先我们要找到函数的地址，那么函数的地址如何表示呢？

函数的地址其实就是&函数名

#include <stdio.h>
void test()
{
	printf("hehe\\n");
}
int main()
{
    printf("%p\\n", test);
    printf("%p\\n", &test);
    return 0;
}
//test和&test地址其实是一样的

知道了函数的地址后怎么写出一个函数指针呢？（引用Add函数）

1. 首先我们写出一个指针*p=&Add，意思是将函数的地址放入一个指针内
2. 然后这个指针指向一个函数，所以 *p()=&Add，又因为 () 的优先级更高一点，如果只是这样写的话， p() 结合在一起就是一个函数的形式了，所以要加括号 ( *p )()=&Add
3. 而这个函数的参数是两个整型，故 ( *p )( int, int )=&Add
4. 最后我们知道这个函数的返回类型是整型，故最后Add函数的指针为： int ( *p )( int, int )=&Add
5. 函数的&函数名与函数名都可以代表函数的地址，故Add函数的指针也可以写成： ( *p )( int, int )=Add

#include <stdio.h>
int Add(int a, int b)
{
	return a + b;
}
int main()
{
	int a = 2;
	int b = 3;
	int(*p1)(int, int) = &Add;
	int(*p2)(int, int) = Add;
    
	return 0;
}
//两个指针意义一样

那么一个函数指针如何使用呢？

• 首先我们将函数指针解引用，函数指针解引用其实我们得到的就是函数，再将参数传进去就可以使用函数指针，形式为：(*p)(a, b)
• 要注意 (*p) 两边的括号不能去掉，因为括号优先级更高，就直接调用函数了

int main()
{
	int a = 2;
	int b = 3;
	int(*p)(int, int) = &Add;
    int ret=Add(a, b);
	printf("%d\\n", ret);
	printf("%d\\n", (*p)(a, b));
	return 0;
}
//两个输出结果一样

注意

1. 函数指针既然可以写成：( *p )( int, int )=Add，说明p == Add
2. 用函数的写法：ret2=Add(a, b);
3. 故将Add换成p，则可以写成：ret3=p(a, b);
4. 故最终我们知道函数指针有两个写法，函数指针使用时解引用那颗星其实是没意义的，甚至你可以再加N个星

int main()
{
	int a = 2;
	int b = 3;
	int(*p)(int, int) = &Add;
    int ret1=(*p)(a,b);
    int ret2=Add(a, b);
	int ret3=p(a,b);
	return 0;
}

练习

练习一：分析下列代码：

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

其实该行代码就是调用0地址处的函数，那怎么分析呢？

1. void(*)()，其实就是一个函数指针类型
2. (void(*)())0，其实就是对0进行强制类型转换，因为函数指针存放的就是个函数地址，所以0被解释为一个函数地址
3. *(void(*)())0，对0地址进行解引用操作，此时相当于一个函数
4. *(void(*)())0()，再将函数参数放入，即是调用0地址处的函数

练习二：分析下列代码：

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

1. 从signal(int , void(*)(int))可以知道signal是一个函数名，函数的第一个参数是整型，第二个参数是一个函数指针类型，该函数指针指向一个参数为int，返回类型是void的函数
2. 将signal(int , void(*)(int))从原式挖去后，得到的是void (*)(int)，这是一个函数指针类型
3. 故signal的返回类型也是一个函数指针，该函数指针指向一个参数为int，返回类型是void的函数。故signal是一个函数的声明

以上代码其实可以换一种形式去理解

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

这种形式的理解就是：有一个signal的函数，其返回值为void (*)(int)。

但是这种形式的语法是不支持的。因为如果这个函数的返回类型是一个指针的话，那么就要将signal(int,void(*)(int))那部放到(*)里面

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

然而我们可以借用typedef对类型进行重定义，使得语法可以被支持

//对void(*)(int)的函数指针类型重命名为pfun_t
typedef void(*pfun_t)(int);

pfun_t signal(int,pfun_t);

小结

1. 函数指针有两种写法，并且使用时指针前面那颗星是没有意义的

2. 函数指针可以类比于数组指针。但是函数指针与数组指针有几大不同点：

1. 数组arr，其数组名等于数组首元素的地址&

   以上是关于一篇文章将你的指针升华的主要内容，如果未能解决你的问题，请参考以下文章

   再见JCenter，将你的开源库发布到MavenCentral上吧

   再见JCenter，将你的开源库发布到MavenCentral上吧

   来，将你的H5游戏一键部署托管到云开发上！

   来，将你的H5游戏一键部署托管到云开发上！

   用 7 行 JSON 代码将你的网站变成移动应用

   第1711期Webpack优化——将你的构建效率提速翻倍