（C语言）指针的进阶

有效的放假者

已于 2023-10-06 20:30:09 修改

阅读量129

点赞数

分类专栏： C语言文章标签：算法开发语言 c语言

于 2022-07-15 15:42:44 首次发布

本文链接：https://blog.csdn.net/qq_55712347/article/details/125640882

版权

C语言专栏收录该内容

22 篇文章 0 订阅

订阅专栏

1. 字符指针

我们在之前已经接触过指针了，知道了指针的概念：

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

这次我们继续探讨指针的高级主题。

在指针的类型中我们知道有一种指针类型为字符指针 char* ;
下面举的例子一个char的两种使用方法，分别存字符和字符串

#include <stdio.h>
int main()
{
	char ch = 'w';
	char* pc = &ch;
	*pc = 'b';
	
	printf("%c\n", ch);

	const char* p = "abcdef";//把字符串首字符a的地址，赋值给了p
	char arr[] = "abcdef";
	*p = 'w';

	printf("%s\n", p);
	return 0;
}

特别容易认为是把字符串 abcdef 放到字符指针p 里了，但本质是把字符串 abcdef . 首字符的地址放到了p中。
在这里插入图片描述
下面的程序输出什么？

int main()
{
	const char* p1 = "abcdef";
	const char* p2 = "abcdef";

	char arr1[] = "abcdef";
	char arr2[] = "abcdef";

	if (p1 == p2)
		printf("p1==p2\n");
	else
		printf("p1!=p2\n");

	if (arr1 == arr2)
		printf("arr1 == arr2\n");
	else
		printf("arr1 != arr2\n");

	return 0;
}

在这里插入图片描述
这里abcdef是一个常量字符串，放在内存的只读数据区（只能用不能改变它的值）里，既然不能改就没有必要存在多份，内存中只会存在一份，所以这里的p1和p2都指向同一个地址（把abcdef字符串交给p1和p2维护）所以输出p1==p2。
对于arr1和arr2数组它是分别开辟的两个不同的内存空间，我们都知道数组名是首元素的地址，数组名不同当然地址也就不同，所以输出arr1!=arr2。

2.指针数组

指针数组顾名思义它是一个存放指针的数组。
在这里插入图片描述
以整型数组和字符数组为例可以类比指针数组，指针数组是存放对应类型的指针的数组。
下面是指针数组的一个用法：

int main()
{
	int arr1[] = { 1,2,3,4,5 };
	int arr2[] = { 2,3,4,5,6 };
	int arr3[] = { 3,4,5,6,7 };
	int* parr[3] = { arr1, arr2, arr3 };

	//0 1 2
	int i = 0;
	for (i = 0; i < 3; i++)
	{
		int j = 0;
		for (j = 0; j < 5; j++)
		{
			//*(p+i) --> p[i]

			printf("%d ", *(parr[i] + j));
			printf("%d ", parr[i][j]);
		}
		printf("\n");
	}
	return 0;
}

我们之前学过*(p+i) --> p[i]，所以*(parr[i] + j)和parr[i][j]是等价的，这里感觉像是二维数组但是其实arr1、arr2、arr3不是存放在一片连续的存储空间，与二维数组还有一定区别。

3. 数组指针

3.1 数组指针的定义

数组指针是指针？还是数组？
答案是：指针。
我们已经熟悉：
整形指针： int * pint; 是指向整形数据的指针。
浮点型指针： float * pf; 是指向浮点型数据的指针。
那数组指针应该是指向数组的指针。

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

3.2 &数组名和数组名的区别

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

在这里插入图片描述
根据上面的代码我们发现，其实&arr和arr，虽然值是一样的，但意义是不一样的。

实际上： &arr 表示的是一整个arr数组的地址，而不是数组首元素的地址。上面代码的 &arr 的类型是： int(*)[10] ，是一种数组指针类型，数组的地址+1，跳过整个数组的大小，所以 &arr+1 相对于 &arr 的差值是40。
注意：如果强制把一个数组的地址放在整形指针里会报警告，就像这样int p = &arr，但是这是不对的，正确做法应该是int (* p)[10] = &arr；*

数组名通常表示的都是数组首元素的地址但是有2个例外：

sizeof(数组名),这里的数组名表示整个数组，计算的是整个数组的大小
&数组名，这里的数组名表示的依然是整个数组，所以&数组名取出的是整个数组的地址

3.3 数组指针的使用

既然数组指针指向的是数组，那数组指针中存放的应该是数组的地址。
看下面的例子：
一般二维数组传参就可以直接用二维数组来接收类似print1函数这样。
但是如何用一个指针来接收一个二维数组参数呢？
其实是类似printf2函数这样。
类比一维数组传参。
在这里插入图片描述

void print1(int arr[3][5], int r, int c)
{
	int i = 0;
	for (i = 0; i < r; i++)
	{
		int j = 0;
		for (j = 0; j < c; j++)
		{
			printf("%d ", arr[i][j]);
		}
		printf("\n");
	}
}

void print2(int (*p)[5], int r, int c)
{
	int i = 0;
	for (i = 0; i < r; i++)
	{
		int j = 0;
		for (j = 0; j < c; j++)
		{
			//printf("%d ", *(*(p + i) + j));
			printf("%d ", p[i][j]);
		}
		printf("\n");
	}
}

int main()
{

	int arr[3][5] = { 1,2,3,4,5,2,3,4,5,6,3,4,5,6,7 };
	print2(arr, 3, 5);
	
	int data[10] = {1,2,3,4,5,6,7,8,9,10};
	return 0;
}

对于* ( * ( p + i) + j)的解释：p是首元素的地址，也就是二维数组一行的起始地址，p+i是第i行的地址，* ( p + i)代表第i行，* ( p + i) + j代表第i行第j个元素的地址，* ( * ( p + i) + j)就代表第i行第j个元素。个人感觉还是用p[ i ] [ j ] 更好理解，还是要从最基本的* ( p + i)<==>p[i]来理解。

小结：数组名arr，表示首元素的地址，二维数组的首元素是二维数组的第一行，这里传递的arr，相当于第一行的地址，是一维数组的地址，那么函数传参时就要用数组指针来接收。（数组的地址就要放到数组指针里边去）

对于下面代码的解释：
int [arr5] ; arr是整型数组
int parr1[10]； parr1整型指针数组
int（*parr2）[10]；parr2是数组指针
int（*parr3[10]）[5]； parr3应该是存放数组指针的数组，下面的图片可以解释parr3数组。
在这里插入图片描述

4. 数组参数、指针参数

在写代码的时候难免要把【数组】或者【指针】传给函数，那函数的参数该如何设计呢？

4.1 一维数组传参

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

以上几种形式都可以进行传参，数组传参数组接收。也可以运用指针传参，最根本的就是要知道，数组名是首元素的地址，首元素是什么类型的，它的指针（地址）类型又是什么？例如：test2(arr2);数组名arr2是首元素int类型的地址，所以用指针传参时，int类型的地址就是二级指针int**，所以是void test2(int **arr)。

4.2 二维数组传参

下面是几个例子：

数组接收：
void test(int arr[3][5]){}//ok

void test(int arr[ ][ ] ){}//这样是不行的，二维数组在定义和传参时，行可以省略，列不能省略。

void test(int arr[][5]){}//ok

总结：【】里的内容要么全写，要么省略行，而且都要匹配上。二维数组传参，函数形参的设计只能省略第一个[]的数字。因为对一个二维数组，可以不知道有多少行，但是必须知道一行多少元素。这样才方便运算。

指针接收：
void test(int *arr){}

//这样是不行的，数组名是首元素的地址，首元素是一个一维数组，要用数组指针的形式来接收

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

//这样也不行，理由同上，这里是一个存放5个int*类型指针的指针数组，也不行

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

//arr首元素的地址，首元素是5个整形，这里的指针数组也是5个元素，每个元素是整形，满足条件。

void test(int **arr){}

//二级指针是用来存放一级指针变量的地址，而这里要存放的是一个数组的地址。所以也不行。

int main()
{
int arr[3][5] = {0};//二维数组，首元素是一维数组。
test(arr);
}

4.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;
}

思考：当一个函数的形式参数部分为一级指针的时候，函数能接收什么参数？
如果是函数的参数部分是指针，有如下三种

void print(int*p）
int a=10;
int* ptr =&a;
int arr[10];
print (&a);//1
print (ptr);//2
print (arr);//3

4.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;
}

思考：如果函数的形式参数是二级指针，调用函数的时候可以传什么实参呢？
有下列三种例子。

 test（int**p）
 {}
int*p1;
int**p2;
int*arr[10]://指针数组,数组名首元素int*的地址
test(&p1);//1
 test(p2);//2
 test(arr)://3

5. 函数指针

首先看下面的例子：
在这里插入图片描述
输出的是两个地址，这两个地址是 test 函数的地址。
那我们的函数的地址要想保存起来，怎么保存？

int test(const char* str)
{
	printf("test()\n");
	return 0;
}

int main()
{
	//函数指针 - 也是一种指针，是指向函数的指针
	printf("%p\n", test);
	printf("%p\n", &test);
	int (* pf)(const char*) = test;
	(*pf)("abc");
	//pf 和 test
	test("abc");
	pf("abc");

	return 0;
}

其中int (* pf)(const char*) = test;是函数指针的定义方法，要和本来的函数int test(const char* str)对比来看，写清楚返回值类型、参数类型，至于参数的类型的名字可有可无，然后是等号和函数名。

使用时有下列三种方法

(*pf)("abc"); //（*   ）其实可有可无写成（* * * * * pf）也可以。但是不能写成*pf
(pf)("abc");
pf("abc");

他们统统等价于test(“abc”);，都可以调用test函数。

阅读下面的两段有趣的代码

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

(void ( * )( ) ) 0是对0地址进行强制类型转换，以上代码本质上是一次函数调用，调用的是0作为地址处的函数
首先把0强制类型转换为：没有参数，返回类型是void的函数的地址，然后调用0地址处的这个函数。

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

解释：signal是函数名，以上代码是一次函数声明。（函数声明省略形参名）
函数声明什么时候可以省略，什么时候不可以省略
 函数声明什么可以省略什么不可以省略（参考这篇文章的注意事项）
声明的signal函数的第一个参数的类型是int，第二参数的类型是函数指针类型，该函数指针指向的函数参数是int，返回类型是void。signal函数的返回类型也是一个函数指针，该函数指针指向的函数参数是int，返回类型是void。

这里可以把void(*)(int)类型重命名为pf_t类型，把上面的代码化简为下面的形式更好理解。
typedef void( * pf_t )(int);
pfun_t signal(int, pf_t);

函数指针的用途

利用函数指针可以实现回调函数
这样写可以避免代码冗余。下面的例子就是防止case条件里的代码冗余。

case 1:
			calc(Add);
			break;

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 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 calc(int (*pf)(int , int))
{
	int x = 0;
	int y = 0;
	int ret = 0;

	printf("请输入2个操作数:>");
	scanf("%d %d", &x, &y);
	ret = pf(x, y);
	printf("%d\n", ret);
}

int main()
{
	int input = 0;

	do
	{
		menu();
		printf("请选择:>");
		scanf("%d", &input);
		
		switch (input)
		{
		case 1:
			calc(Add);
			break;
		case 2:
			calc(Sub);
			break;
		case 3:
			calc(Mul);
			break;
		case 4:
			calc(Div);
			break;
		case 0:
			printf("退出计算器\n");
			break;
		default:
			printf("选择错误\n");
			break;
		}
	} while (input);

	return 0;
}

6. 函数指针数组

上面的例子中
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;
}
这几个函数的参数、返回类型都相同，那么就可以把四个函数的地址放到函数指针数组里。
就像这样
int (*arr[4])(int, int) = { Add, Sub, Mul, Div };//arr就是函数指针的数组
在这里插入图片描述
其实函数指针数组的用途：转移表
当有函数指针数组时，针对上面计算器例子就可以进行代码优化

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

int main()
{
	int input = 0;
	int x = 0;
	int y = 0;
	int ret = 0;

	//函数指针的数组
	//转移表
	int (*pfArr[])(int, int) = {0, Add, Sub, Mul,  Div};

	do
	{
		menu();
		printf("请选择:>");
		scanf("%d", &input);
		if (input == 0)
		{
			printf("退出计算器\n");
		}
		else if (input >= 1 && input <= 4)
		{
			printf("请输入2个操作数:>");
			scanf("%d %d", &x, &y);
			ret = pfArr[input](x, y);
			printf("%d\n", ret);
		}
		else
		{
			printf("选择错误\n");
		}

	} while (input);

	return 0;
}

好处是当再往里边添加其他功能的时候，所需要改的代码相对更少。

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

那么函数指针数组也是一个数组，&数组名就代表数组的地址，那数组的地址该放在哪里呢？
这就要依靠指向函数指针数组的指针了
指向函数指针数组的指针也是一个指针，指针指向一个数组，数组的元素都是函数指针 ;
指向【函数指针数组】的指针
以这个函数指针数组为例int ( * arr[4])(int, int) ；
int（*（*parr)[4])（int，int）=&arr；
当前parr就代表函数指针数组的地址（指针）。
下面代码有更加详细的步骤

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

8. 回调函数

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

有效的放假者

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
打赏
0
评论
（C语言）指针的进阶

数组指针是指针？还是数组？答案是指针。我们已经熟悉整形指针是指向整形数据的指针。浮点型指针是指向浮点型数据的指针。那数组指针应该是指向数组的指针。解释p先和*结合，说明p是一个指针变量，然后指着指向的是一个大小为10个整型的数组。所以p是一个指针，指向一个数组，叫数组指针。这里要注意[]的优先级要高于*号的，所以必须加上（）来保证p先和*结合。而且类比inta，a的类型是int，那么这里int(*p)[10]的类型就是。.........
复制链接

扫一扫