• C语言指针进阶：各类型指针变量详解

    目录

    正文开始。

    1. 字符指针变量

    我们可以通过指针来指向一个字符变量
    例如：

    int main()
{
	char ch = 'a';
	char* pch = &ch;
	return 0;
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6

    还可以这样：

    int main()
{
	const char* pstr = "hello world!";
	return 0;
}

    • 1
    • 2
    • 3
    • 4
    • 5

    上述第三行代码，很容易让人理解为是把字符串hello world!放到了字符指针pstr里了。但其实这里本质是把字符串hello world!的首字符的地址放到了pstr里。

    值得注意的是：当几个指针指向同一个字符串的时候，他们实际会指向同一块内存。这也不难理解，某一字符串是独一无二的，没必要为同一个东西再开辟空间。

    例如：

    #include 
int main()
{
	char str1[] = "hellw world!";
	char str2[] = "hellw world!";
	const char *str3 = "hellw world!";
	const char *str4 = "hellw 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;
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18

    运行结果：
    在这里插入图片描述
    从这里就可以看出，几个指针指向同一个字符串的时候，他们会指向同一块内存；但用相同的字符串去初始化不同的数组时，就会开辟处不同的内存块。

    2. 数组指针变量

    2.1 什么是数组指针变量

    在上一篇文章中，我们学习了指针数组，它是存放指针的数组。
    类比指针数组，不难理解，数组指针变量就是指向数组的指针变量

    下面我们来看两种变量：

    //指针数组 - 存放指针的数组
int* p1[10];

//数组指针变量 - 指向数组的指针变量
int (*p2)[10];

    • 1
    • 2
    • 3
    • 4
    • 5

    理解：

    • *的优先级低于[]
    • int* p1[10]中p1先与[10]结合，代表数组类型，int *指明数组中元素的类型为整型指针
    • int (*p2)[10]中p2先与 * 结合，代表指针类型，int [10]代表所指向对象的类型为存放了十个整型元素的数组

    2.2 数组指针变量的初始化

    数组指针变量是用来存放数组地址的，我们可以通过取地址操作符&来获取数组地址。

    int main()
{
	int arr[10] = { 0 };
	//数组指针变量的初始化
	int (*p)[10] = &arr;
	return 0;
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7

    3. 二维数组传参的本质

    在我们将一个二维数组传递给一个函数时，我们是这样写的：

    #include 

void Print(int arr[2][3], int row, int col)
{
	int i = 0;
	int j = 0;
	for(i = 0; i< row; i++)
	{
		for(j = 0; j < col; j++)
		{
			printf("%d ",arr[i][j]);
		}
		printf("\n");
	}
}

int main()
{
	int arr[2][3] = {{1,2,3}, {2,3,4}};
	Print(arr,2,3);
	return 0;
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22

    我们再重新理解下二维数组，二维数组定义时，通常像这样int arr[2][3]，这里我们可以看作是这样的int (arr[2])[3]，即一维数组里面存放的元素是一维数组，这样就把一个二维数组拆分成了两个一维数组来看。例如第一行的一维数组的类型就是int [3]，所以第一行的地址的类型就是数组指针类型int(*)[5]。通过这一点，我们不难理解，二维数组传参本质上也是传递了参数，传递的是第一行这个一维数组的地址。

    那么，我们二维数组传参，也可以写成这样：

    #include 

void Print(int (*p)[3], int row, int col)
{
	int i = 0;
	int j = 0;
	for(i = 0; i < row; i++)
	{
		for(j = 0; j < col; j++)
		{
			printf("%d ", *(*(p + i) + j));
			//p + i == &arr[i]
			//*(p + i) == arr[i] 相当于第i行一维数组的数组名
			//*(p + i) + j == &arr[i][j]
			//*(*(p + i) + j) == arr[i][j]
		}
		printf("\n");
	}
}
int main()
{
	int arr[2][3] = {{1,2,3}, {2,3,4}};
	Print(arr,2,3);
	return 0;
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25

    上述代码运行结果：
    在这里插入图片描述

    4. 函数指针变量

    函数指针变量，顾名思义，它就是存放函数地址的指针变量。

    在学习函数指针变量前，我们要了解到，函数名就是函数的地址。

    例如：

    #include 
//函数地址 -- &Add
//函数地址 -- Add
int Add(int x, int y)
{
	return x + y;
}
int main()
{
	printf("&Add = %p\n", &Add);
	printf("Add  = %p\n", Add);
	return 0;
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13

    上述代码运行结果：
    在这里插入图片描述

    4.1 函数指针变量的创建

    当我们想把函数的地址存放起来，这是就需要用到函数指针变量了，函数指针变量的写法与数组指针非常类似。例如：

    #include 

int Add(int x, int y)
{
	return x + y;
}
int main()
{
	int (*p1)(int, int) = Add;
//或int (*p2)(int x, int y) = Add;
//Add也可写为&Add，它们都代表函数的地址

//int    (*p1)     (int, int)
// |       |       ——————————
// |       |            |
// |       |            |
// |       |       p1指向函数的参数类型和个数的声明
// |       函数指针变量名
// p1指向函数的返回类型
//
// p1的类型 -- int (*) (int x, int y)
	return 0;
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23

    4.2 函数指针变量的使用

    我们可以通过函数指针调用指针指向的函数

    #include 

int Add(int x, int y)
{
	return x + y;
}
int main()
{
	//函数指针变量定义
	int (*p1)(int, int) = Add;
	//函数指针变量使用
	printf("%d\n",(*p1)(3,4));
	printf("%d\n", p1(5,1));
	return 0;
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15

    上述代码运行结果：
    在这里插入图片描述

    4.3 代码分析

    我们来看下面两个代码

    代码1：

    (*(void (*)())0))();
//void (*)() -- 函数指针类型，所指向对象无形参，无返回值

//(void (*)())0 -- 将0强制转换类型为void (*)()类型，即将0地址处存放函数的地址

//*(void (*)())0) -- 解引用函数指针

//(*(void (*)())0))() -- 调用函数指针变量指向的函数

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8

    代码2：

    void (*signal(int, void(*)(int)))(int);
//void(*)(int) -- 函数指针变量，指向的函数无返回值，参数类型为int

//signal(int, void(*)(int)) -- 函数名为signal的函数，第一个参数类型为int，第二个参数类型为void(*)(int)

//void (*signal(int, void(*)(int)))(int) -- 函数signal(int, void(*)(int))的声明，它的返回值类型为void (*)(int)

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6

    4.3.1 typedef 关键字

    上面我们写的代码二的作用就是声明一个函数，可以看出来，这个函数声明非常的复杂，我们可以通过typedef关键字来重命名类型，简化类型。

    例如：

    typedef int i;
//将 int 重命名为 i

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

typedef int(*parr)[5];
//将 int (*)[5] 重命名为 parr

typedef void(*pfun)(int);
//将 void(*)(int) 重命名为 pfun

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11

    若要简化代码2，我们可以这样写：

    typedef void(*pfun)(int);
//将 void(*)(int) 重命名为pfun

pfun signal(int, pfun);

    • 1
    • 2
    • 3
    • 4

    5. 函数指针数组

    函数指针数组，就是存放函数指针变量的数组。

    定义如下：

    int (*parr[4])();
//  parr -- 数组名
//  [4] -- 数组元素个数
//  int (*)() -- 数组中元素的类型

    • 1
    • 2
    • 3
    • 4

    6. 转移表

    函数指针数组可以用来书写转移表——运用函数指针数组以数组方式去调用里面的函数，从而在某些情况下替代冗长的代码。我们通过计算器的例子来学习一下吧。

    计算器的一般实现：

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

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46
    • 47
    • 48
    • 49
    • 50
    • 51
    • 52
    • 53
    • 54
    • 55
    • 56
    • 57
    • 58
    • 59
    • 60
    • 61
    • 62
    • 63
    • 64
    • 65
    • 66
    • 67
    • 68

    使用转移表实现计算器：

    #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 (*arr[5])(int, int) = {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 >= 1 && input <= 4)
		{
			printf("输入操作数：");
			scanf("%d%d", &x, &y);
			ret = *(arr[input])(x,y);//调用函数指针数组中的元素
			printf("ret=%d\n", ret);
		}
		else if(input == 0)
		{
			printf("程序退出\n");
		}
		else
		{
			printf("输入错误\n");
		}
	} while(input);
	return 0;
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46
    • 47
    • 48
    • 49
    • 50

    完。

  • 相关阅读:
    固话号码认证有什么好处？固话号码认证有什么作用？
    聊聊Mybatis的初始化之Mapper.xml映射文件的解析
    【嵌入式开发学习】__单片机中容易造成内存泄露的几个痛点
    【Java+SpringBoot】原材料管理系统_仓库管理系统（源码+远程部署+项目定制开发+代码讲解+答辩教学+计算机毕业设计+计算机毕设）
    微机原理与接口技术-第八章常用接口技术
    批量上传图片添加水印
    数据结构学习笔记（二）----线性表（上）
    利用视觉分析技术提升水面漂浮物、水面垃圾检测效率
    SpringMvc的工作流程是怎样的
    说一下 ArrayDeque 和 LinkedList 的区别?
  • 原文地址：https://blog.csdn.net/qq_67140973/article/details/137747409