深入理解指针 * chapter 3

Novice grey

已于 2024-01-27 22:27:07 修改

阅读量904

点赞数 31

文章标签： c语言

于 2024-01-21 16:34:50 首次发布

本文链接：https://blog.csdn.net/m0_74251523/article/details/135728358

版权

目录

1. 字符指针变量

2.数组指针变量

2.1 数组指针变量的定义

2.2 数组指针变量初始化

3. 二维数组传参的本质

4. 函数指针变量

4.1 函数指针变量的创建

4.2 函数指针变量使用

4.3 分析两行特殊代码

4.3.1 typedef 关键字

5. 函数指针数组

6. 转移表

总结

指针在编程中扮演着至关重要的角色，首先，指针是内存的标签，通过它我们可以定位到内存中的特定位置。这种能力允许程序员直接操作内存地址，从而增加了编程的灵活性和效率。

1. 字符指针变量

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

使用方法有：

1 int main()
2 {
3 char ch = 'w';
4 char* pc = &ch;
5 *pc = 'w';
6 return 0;
7 }

1 int main()
2 {

3 const char* pstr = "hello bit.";
4 printf("%s\n", pstr);
5 return 0;
6 }

第二个例子中注意，代码 const char* pstr = "hello bit." 本质是把字符串 hello bit. 的首字符 h 的地址放到了pstr中，而不是把字符串 hello bit 放到字符指针 pstr 里。当常量字符串出现在表达式中，它的值是第一个字符的地址。

《剑指offer》中收有一道和字符串相关的笔试题，值得学习：

#include <stdio.h>

int main()
{
	char str1[] = "hello bit.";
	char str2[] = "hello bit.";
	const char* str3 = "hello bit.";
	const char* str4 = "hello bit.";//内容相同的常量字符串只会保存一份
	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;
}

运行结果

这里str3和str4指向的是同一个常量字符串。C/C++会把常量字符串存储到单独的一个内存区域，当几个指针指向同一个字符串的时候，他们实际会指向同一块内存。但是用相同的常量字符串去初始化不同的数组的时候就会开辟出不同的内存块。所以str1和str2不同，str3和str4相同。

2.数组指针变量

2.1 数组指针变量的定义

数组指针变量是指针变量。已知的指针变量有：

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

辨析哪个是数组指针:

1 int *p1[10];

2 int (*p2)[10];

p1是数组，数组10个元素，每个元素类型是int*, 所以第一个是指针数组

p2是指针，指针指向的是数组，数组有10个元素，每个元素类型是int , 所以第二个为数组指针

数组指针变量

1 int (*p)[10];

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

注意：[ ]的优先级高于*，所以必须加上（）保证p先和*结合。

2.2 数组指针变量初始化

首先要获取数组地址

1 int arr[10]={0};

2 &arr; //得到数组的地址

数组的地址得存放在数组指针变量中

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

通过调试可得 &arr 和 p 的类型完全一致。

数组指针类型解析：

3. 二维数组传参的本质

二维数组可以看做是每个元素是一维数组的数组，也就是二维数组的每个元素是一个一维数组。二维数组的首元素就是第一行，是个一维数组。

如图：

根据数组名是数组⾸元素的地址这个规则，二维数组的数组名表示第一行的地址，是一维数组的地址。第一行的一维数组的类型就是 int [5] ，所以第一行的地址的类型就是数组指针类型 int(*)[5] 。那就意味着二维数组传参本质上也是传递了地址，传递的是第一行这个一维数组的地址，那么二维数组传给函数时，形参可以写成指针形式的。如下：

#include <stdio.h>

void test(int(*p)[5], int r, int c)//int a[3][5]
{
	int i = 0;
	int j = 0;
	for (i = 0; i < r; i++)
	{
		for (j = 0; j < 0; j++)
		{
			printf("%d ", *(*(p + i) + j));//a[i][j]
			//p+0指向第一行arr[0]
			//p+1指向第二行arr[1]
			//p+2指向第三行arr[2]
		}
		printf("\n");
	}
}
int main()
{
	int arr[3][5] = { {1,2,3,4,5},{2,3,4,5,6},{3,4,5,6,7} };
	test(arr, 3, 5);
	return 0;
}

总结：二维数组传参，形参的部分可以写成数组，也可以写成指针形式。

4. 函数指针变量

4.1 函数指针变量的创建

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

先做一个测试看函数是否有地址：

#include <stdio.h>

void test()
{
		printf("hello grey.");
}
int main()
{
	printf("test: %p\n", test);
	printf("&test: %p\n",&test);
	return 0;
}

运行结果

通过运行结果可得打印出来了地址，所以函数是有地址的，函数名就是函数的地址，也可以通过 &函数名的方式获得函数的地址。

如果要将函数的地址存放起来，就得创建函数指针变量。解析如下：

使用举例：

#include <stdio.h>

void test()
{
		printf("hello grey.");
}
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可不写

4.2 函数指针变量使用

通过函数指针调⽤指针指向的函数：

#include <stdio.h>

int Add(int x, int y)
{
	return x + y;
}

int main()
{
	int(*pf3)(int, int) = Add;
	printf("%d\n", (*pf3)(2, 3));
	printf("%d\n", pf3(1,6));
	return 0;
}

运行结果

4.3 分析两行特殊代码

代码1

1 （* (void(*)()) 0)();

void(*p)()是函数指针变量，void(*)()是函数指针类型，这行代码是一次函数调用，把0这个int数值强制类型转换为一个函数地址，然后调用0地址处的函数。

代码 2

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

signal是一个函数，有两个参数，它的返回类型是void(*)(int)，signal的第一个参数是int型，第二个参数是函数指针类型，该指针指向类型的函数参数是int型，返回类型是void。

4.3.1 typedef 关键字

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

例如，unsigned int 写起来不方便，写成 uint 就方便多了，如下：

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

指针类型也可以重命名，例如将 int* 重命名为 ptr_t ：

1 typedef int* ptr_t;

但对于数组指针和函数指针有点区别，比如有数组指针类型 int(*)[5] ,需要重命名为 parr_t ，可以这样写：

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

函数指针类型的重命名同理，比如将 void(*)(int) 类型重命名为 pf_t ,就可以这样写：

1 typedef void(*pfun_t)(int); //新的名称必须在*的右边

这样，可以将代码2的复杂形式化简如下：

1 typedef void(*pfun_t)(int);

2 pfun_t signal(int, pfun_t);

5. 函数指针数组

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

1 int (*parr1 [3]) ();

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

6. 转移表

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

举例：计算器的一般实现：

#include <stdio.h>

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

使用函数指针数组：

#include <stdio.h>

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

运行结果

总结

指针在C语言中的地位非常重要，它是最基础和最重要的概念之一。指针的存在让C语言可以进行复杂的内存操作，更好地控制程序的行为，同时也能够实现高效的数据结构和算法。
通过指针能实现所谓的“传引用”而不是“传值”，这在函数参数传递时可以有效地改变参数的值，而不仅仅是复制一份参数的值，从而在本质上节约了数据传输性能。其次，C语言支持指针的运算（对指针加减，甚至取指针），这是C语言强大的地方。同时，指针也用于表示和实现各种复杂的数据结构，比如系统地动态分配内存、消息机制、任务调度等。此外，利用指针可以直接操纵内存地址，从而可以完成和汇编语言类似的工作。
需要注意的是，指针是一个强大但同时也是比较危险的工具。如果不正确使用指针，比如误操作空指针，可能会导致程序崩溃或者产生其他错误。因此，学习和使用指针需要谨慎对待。总的来说，指针在C语言中的地位不可替代，掌握好指针的使用是学习C语言的关键之一。