认识指针（3）

在下Z.

已于 2024-04-09 16:29:53 修改

阅读量589

点赞数 15

文章标签：算法

于 2024-04-09 16:27:33 首次发布

本文链接：https://blog.csdn.net/zhou_yi_ping/article/details/137376829

版权

补充：int*p[10] //存放指针变量的数组

int(*p)[10] //指向数组的指针

1.字符指针变量

在指针的类型中我们知道有一种指针类型为字符指针char*。

一种使用方法：

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

另一种使用方法

int main()
{
	const char* pstr = "hello world";
	printf("%s\n", pstr);
	return 0;
}

该代码是把字符串hello world首字符的地址放到了pstr中。

关于字符串的题目

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和str虽然字符串都是hello world但是地址不一样

str3和str4的地址所指向的都是hello world，所以他们的地址一样（当几个指针指向同一个字符串的时候，他们实际会指向同一块内存）

相同的常量字符串中，没必要保存2份，因为常量字符串不能被修改。

2.数组指针变量

之前我们学习了指针数组，指针数组是一种数组，数组中存放的是地址（指针）

那么数组指针变量是指针变量

整形指针变量：int*pint;存放的是整型变量的地址，能够指向整型数据的指针。
浮点型指针变量：float*pf；存放浮点型变量的地址，能够指向浮点型数据的指针。

那数组指针变量应该是：存放数组的地址，能够指向数组的指针变量。

int* p1[10];
int(*p2)[10];

下面哪个是数组指针变量

p与方块[ ]结合，就是数组名，所以p1是指针数组，存放指针的数组。

p2指针变量，指向的是数组，把p2去掉，int*就是该指针的类型。

[ ]的优先级要高于*，所以要加括号来保证p与*先结合。

2.2 数组指针变量怎么初始化

数组指针变量是用来存放数组地址的，那怎么获得数组的地址呢，所以我们就要用到&数组名

int arr[10] = { 0 };
&arr;

如果要存放这个数组的地址，就得存放在数组指针变量中

int(*p)[10] = &arr;

经调试，我们可以看到p与&arr的类型是一致的。

牛刀小试：运用指针访问数组

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

以下代码过于繁琐，错误示范

#include<stdio.h>
int main()
{
	int arr[5] = { 1,2,3,4,5 };
	int(*p)[5] = &arr;//*&arr=arr
	int i = 0;
	for (i = 0; i < 5; i++)
	{
		printf("%d", (*p)[i]);//*p指整个数组
	}
	return 0;
}

3.二维数组传参的本质

过去我们有一个二维数组的需要传参的时候，我们会这样写：

void test(int arr[2][3], int r, int c)
{
	int i, j;
	for (i = 0; i < 2; i++)
	{
		for (j = 0; j < 3; j++)
		{
			printf("%d ", arr[i][j]);
		}
		printf("\n");
	}
}
int main()
{
	int arr[2][3] = { {1,2,3},{2,3,4} };
	test(arr, 2, 3);
	return 0;
}

这里实参是二维数组，形参也写成二维数组，那还有其他的写法吗？

我们可以理解二维数组起始可以看作是每个元素是一维数组的数组，也就是二维数组的每个元素是一个一维数组。

arr数组
	0	1	2	3	4
0	1	2	3	4	5
1	2	3	4	5	6
2	3	4	5	6	7

因为数组名是数组首元素的地址，二维数组的数组名表示的就是第一行的地址，是一维数组的地址。根据表格，第一行的一维数组的类型就是int[5]，所以第一行的地址的类型就是数组指针的类型int(*)[5]。哪就意味着二维数组传参的本质也是传递了地址，传递的是第一行这个一维数组的地址，所以形参也可以写成指针形式

void test(int(*p)[3], int r, int c)
{
	int i, j;
	for (i = 0; i < 2; i++)
	{
		for (j = 0; j < 3; j++)
		{
			printf("%d ", *(*(p + i) + j));
		}
		printf("\n");
	}
}
int main()
{
	int arr[2][3] = { {1,2,3},{2,3,4} };
	test(arr, 2, 3);
	return 0;
}

4.函数指针变量

4.1函数指针变量的创建

函数指针变量应该是用来存放函数地址的，未来通过地址能够调用函数。

判断函数是否有地址？

void test()
{
	printf("hehe\n");
}
int main()
{
	printf("test:%p\n", test);//%p是打印地址
	printf("&test:%p\n", &test);
	return 0;
}

结果可见函数是有地址的，函数名就是函数的地址，也可以通过&函数名的方式获得函数的地址。

如果我们要将函数的地址存放起来，就得创建函数指针变量。

void test()
{
	printf("hehe\n");
}
void(*pf1)() = &test;
void(*pf2)() = test;
int Add(int x, int y)
{
	return x + y;
}
int(*pf3)(int, int) = Add;
int(*pf3)(int x, int y) = &Add;//x和y写上或省略都可以

int --pf3指向函数的返回类型

pf3--函数指针变量名

(int x ,int y)--pf3指向函数的参数类型和个数的交代

4.2函数指针变量的使用

通过函数指针调用指向的函数

void Add(int x, int y)
{
	return x + y;
}
int main()
{
	int(*pf3)(int x, int y) = Add;
	printf("%d\n", (*pf3)(2, 3));
	printf("%d\n", pf3(3, 5));
	return 0;
}

另一种写法

int Add(int x, int y)
{
	return x + y;
}
int main()
{
	int(*pf)(int, int) = Add;
	int c = Add(2, 3);
	printf("%d\n", c);
	int d = (*pf)(3, 4);
	printf("%d\n", d);
	int e = pf(4, 5);
	printf("%d\n", e);
	return 0;
}

三种调研形式都可。

4.3有趣的代码

1.(*(void(*)())0)();

解读：void(*)()--函数指针类型

(void(*)())--强制类型转换

(void(*)())0--将0强制类型转换为void(*)()的函数指针类型

这就意味着我们假设0地址处放着无参，返回类型是void的函数，最终是调用0地址处放的这个函数。

4.3.1typedef关键字

typedef是用来类型重命名的，可以将复杂的类型，简单化。

比如：会觉得unsigned int写起来不方便，如果可以写成uint就方便多了，我们可以使用

typedef unsigned int uint;//将unsigned int 重命名为uint

如果是指针，同样也可以

比如有数组指针类型int(*)[5],重命名为parr_t,那可以这样写

typedef int(*parr_t)[5];//新的类型名必须在*的右边

函数指针类型的重命名也是一样的，将int(*)(int)类型重命名为pf_t

typedef int(*pfun_t)(int);

5.函数指针数组

函数指针数组：把函数的地址存到一个数组中，那么如何定义它呢

int (*parr1[3])();

parr是数组，数组的内容是int(*)()类型的函数指针。

6.转移表

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

举例：计算机的一般实现

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;
	do
	{
		printf("**********************\n");
		printf("1:add            2:sub\n");
		printf("3:mit            4:div\n");
		printf("0:exit                \n");
		printf("**********************\n");
		printf("请选择：");
		scanf("%d", &input);
		switch (input)
		{
		case 1:
			printf("请输入操作数：\n");
			scanf("%d%d", &x, &y);
			ret = add(x, y);
			printf("ret=%d\n", ret);
			break;
		case 2:
			printf("请输入操作数：\n");
			scanf("%d%d", &x, &y);
			ret = sub(x, y);
			printf("ret=%d\n", ret);
			break;
		case 3:
			printf("请输入操作数：\n");
			scanf("%d%d", &x, &y);
			ret = mul(x, y);
			printf("ret=%d\n", ret);
			break;
		case 4:
			printf("请输入操作数：\n");
			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;
}

使用函数指针数组的实现：

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