【C语言】指针详细解读4

1. 字符指针变量

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

⼀般我们使用:
 

#include <stdio.h>

int main()
{
	char ch = 'w';
	char* pc = &ch;
	*pc = 'w';
	printf("%c\n", *pc);
	*pc = 'q';
	printf("%c\n", ch);

	return 0;
}

运行结果：

我们还有⼀种使⽤方式如下：

#include <stdio.h>

int main()
{
	//这⾥是把⼀个字符串的第一个字符'h'的地址放进 p 指针变量中
	const char* p = "hello world.";

	//通过这种方式依次遍历整个字符数组
	printf("%s\n", p);

	return 0;
}

运行结果：

代码 const char* p = "hello world."; 特别容易让我们认为是把字符串 hello world. 放到字符指针变量 p ⾥了，但是本质是把字符串 hello world. ⾸字符 h 的地址放到了指针变量 p 中。

上⾯代码的意思是把⼀个常量字符串的⾸字符 h 的地址存放到指针变量 p 中。

2. 数组指针变量

2.1 数组指针变量是什么？

我们知道指针数组，指针数组是⼀种数组，数组中存放的是地址（指针）。

数组指针变量是指针变量？还是数组？

答案是：指针变量。

我们已经知道：

• 整形指针变量： int * pint; 存放的是整形变量的地址，能够指向整形数据的指针。

• 浮点型指针变量： float * pf; 存放浮点型变量的地址，能够指向浮点型数据的指针。

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

我们区分一下 指针数组和 数组指针的区别：

int* arr[10];//指针数组
int (*arr)[10];//数组指针，arr是数组指针变量

解释：

①  arr[10]作为一个整体再与 *结合，这种就被称为 指针数组；

②   arr先和 *结合，说明 arr是⼀个指针变量变量，然后指着指向的是⼀个⼤⼩为10个整型的数组。所以 arr是⼀个指针，指向⼀个数组，叫 数组指针。

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

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

数组指针变量是⽤来存放数组地址的，那怎么获得数组的地址呢？

这就是我们之前学习的 &数组名 。

int arr[10] = {0};
&arr;//得到的就是数组的地址

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

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

通过调试我们也能看到 &arr 和 p 的类型是完全⼀致的。

数组指针类型解析：

int (*p) [10] = &arr;
 |    |    |
 |    |    |
 |    |    p指向数组的元素个数
 |   p是数组指针变量名
 p指向的数组的元素类型

3. ⼆维数组传参的本质

有了数组指针的理解，我们就能够学习⼀下⼆维数组传参的本质了。

过去我们有⼀个⼆维数组的需要传参给⼀个函数的时候，我们是这样写的：

#include <stdio.h>

void test(int a[3][5], int r, int c)
{
	for (int i = 0; i < r; i++)
	{
		for (int j = 0; j < c; j++)
		{
			printf("%d ", a[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} };
	 test(arr, 3, 5);

	 return 0;
 }

运行结果：

这⾥实参是⼆维数组，形参也写成⼆维数组的形式，那还有什么其他的写法吗？

⾸先我们再次理解⼀下⼆维数组，⼆维数组其实可以看做是每个元素是⼀维数组的数组，也就是⼆维数组的每个元素是⼀个⼀维数组。那么⼆维数组的⾸元素就是第⼀⾏，是个⼀维数组。

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

#include <stdio.h>

void test(int (*pa)[5], int r, int c)
{
	for (int i = 0; i < r; i++)
	{
		for (int j = 0; j < c; j++)
		{
			printf("%d ", (*(pa+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} };
	test(arr, 3, 5);

	return 0;
}

运行结果：

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

4. 函数指针变量

4.1 函数指针变量的创建

什么是函数指针变量呢？

根据前⾯学习整型指针，数组指针的时候，我们的类⽐关系，我们不难得出结论：

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

那么函数是否有地址呢？

我们可以测试一下：

#include <stdio.h>

void test()
{
	printf("hehe\n");
}

int main()
{
	printf("test: %p\n", test);
	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; //pf3函数指针变量的类型

函数指针类型解析：

int (*pf3) (int x, int y)
 |     |     ------------ 
 |     |          |
 |     |      pf3指向函数的参数类型和个数的交代
 |   函数指针变量名
 pf3指向函数的返回类型
int (*) (int x, int y) //这是pf3的函数指针类型

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(3, 5));

	return 0;
}

运行结果：

4.3.1 typedef 关键字

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

⽐如，你觉得 unsigned int 写起来不⽅便，如果能写成 uint 就⽅便多了，那么我们可以使⽤：

#include <stdio.h>
typedef unsigned int uint;
//将unsigned int 重命名为uint

int main()
{
	uint a = 10;
	int  b = 10;
	printf("a = %d, b = %d\n", a, b);

	return 0;
}

运行结果：

我们可以看到，uint 和 int 效果是一样的，都可以用来定义一个无符号整型变量。

如果是指针类型，能否重命名呢？其实也是可以的，⽐如，将 int* 重命名为 ptr_t ,这样写：

#include <stdio.h>

typedef int* ptr_t;//将int* 重命名为ptr_t

int main()
{
	int a = 10;
	int b = 20;
	int* pa = &a;
	ptr_t pb = &b;
	*pa = 50;
	*pb = 50;
	printf("a = %d, b = %d\n", a, b);

	return 0;
}

运行结果：

但是对于数组指针和函数指针稍微有点区别：

⽐如我们有数组指针类型 int(*)[5] ,需要重命名为 parr_t ，那可以这样写：

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

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

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

5. 函数指针数组

数组是⼀个存放相同类型数据的存储空间，我们已经学习了指针数组。

⽐如：

int *arr[10];
//数组的每个元素是int*

那么要把函数的地址存到⼀个数组中，那这个数组就叫函数指针数组，那函数指针的数组如何定义呢？

int (*parr1[3])();
int *parr2[3]();
int (*)() parr3[3];

答案是：parr1

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

void menu()
{
	printf("********************************\n");
	printf("*******  1.加法  2.减法  *******\n");
	printf("*******  3.乘法  4.除法  *******\n");
	printf("*******  0.退出计算器    *******\n");
	printf("********************************\n");
}
int main()
{
	menu();
	int(*calc[5])(int,int) = { NULL,Add,Sub,Mul,Div };
	int a = 0;
	int b = 0;
	int input = 0;
	
	do
	{
		printf("请输入你的选择：>");
		scanf("%d", &input);
		printf("\n");
		if (input >= 1 && input <= 4)
		{
			printf("请输入两个整数：>");
			scanf("%d %d", &a, &b);
			int ret = calc[input](a, b);
			printf("%d\n", ret);
		}
		else if (input == 0)
		{
			printf("退出计算器\n");
		}
		else
		{
			printf("选择错误，请重新选择！\n");
		}
	} while (input);

	return 0;
}

运行结果：