1、字符指针变量
定义一个字符型的指针变量，可以这样做：
#include<stdio.h>
int main()
{
char ch[] = { "Hello world" };
char* pc = ch;
*pc = 'w';
printf("%s\n", ch);
return 0;
}
这里我们将字符串存放到了字符数组中。
但其实，我们可以 不用创建数组 ：
#include<stdio.h>
int main()
{
char const * pc = "Hello world";
printf("%s\n", pc);
return 0;
}
上面代码中，我们看起来是把整个 "Hello world" 存放到指针变量 pc 中，但其实，还是存放的是 首元素的地址 ：
#include<stdio.h>
int main()
{
char const * pc = "Hello world";
printf("%p\n", pc);
printf("%c\n", *pc);
return 0;
}
注意上面代码中， printf("%c\n", *pc); 中的 c 不能改成 s 。
看一道例题：
#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");//语句1
else
printf("str1 and str2 are not same\n");//语句2
if(str3 == str4)
printf("str3 and str4 are same\n");//语句3
else
printf("str3 and str4 are not same\n");//语句4
return 0;
}
为什么会打印语句2、3呢？
要知道， str1、str2、str3、str4 对应的都是首元素的地址。
对于两个数组 str1[ ]、str2[ ] ，系统分别给他俩分配了两块内存，所以作为地址， str1、str2 是不一样的。
而对于指针变量 str3、str4 ，由于 "hello bit." 是一个常量，系统分配给它的地址是固定的，即首元素地址是固定的。因此str3、str4 是一样的。
2、数组指针变量
概念：
- 用于存放数组地址的指针变量，指向对象是数组。
理解：
#include<stdio.h>
int main()
{
int arr[5] = { 0 };
int (*parr)[5] = &arr;
return 0;
}
- (*parr) ，即 parr 和 * 绑在一起 ，说明 parr 是指针变量。 parr 是变量名。
- [5] ，说明 parr 指向的数组有5个元素。
- int ，说明 parr 指向数组的每个元素的类型是 int 类型。
所以，此时指针变量 parr 的类型： int (*)[5] 。
初始化：
#include<stdio.h>
int main()
{
int arr[5] = { 0 };
int (*parr)[5] = &arr;
return 0;
}
3、二维数组传参的本质
二维数组，其实可以看做元素为一维数组而组成的一维数组。所以二位数组传参，传递的是第一行数组的地址。
#include<stdio.h>
void Print(int arr[3][5], int x, int y)
{
for (int i = 0; i < x; i++)
{
for (int j = 0; j < y; j++)
{
printf("%d ", arr[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} };
Print(arr, 3, 5);
return 0;
}
既然二维数组传参，传递的是第一行一维数组的的地址，那么上面代码中，函数形参部分也可以写成指针变量形式。
#include<stdio.h>
void Print(int (*parr)[5], int x, int y)
{
for (int i = 0; i < x; i++)
{
for (int j = 0; j < y; j++)
{
printf("%d ", *(*(parr+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} };
Print(arr, 3, 5);
return 0;
}
打印数字代码中，为什么 arr[ i ][ j ] 替换成了 *(*(parr+i)+j)) ？
由前面二维数组传参的本质，我们可以知道， parr + 0 是第0行的地址， parr + 1 是第1行的地址， parr + 2 是第2行的地址。
这时，我们将 parr + i 解引用，得到的就是每一行数组（的数组名）。 *(parr + i) 相当于 *(arr + i) ，相当于 arr[ i ] 。
而数组名又代表数组首元素的地址，那么 *(parr + i) + j 就是第 i 行、第 j 个元素的地址，对其解引用，就是对应的元素。
4、函数指针变量
4.1、创建
概念：
- 函数指针变量，就是存放函数地址的变量，可以通过此变量存放的地址调用函数。
那么函数有没有地址呢？
答案是有的。我们可以直接利用函数名来获得地址，也可以使用格式 &函数名 来获得地址。
函数指针变量的格式与数组指针变量的格式类似。
#include<stdio.h>
void test()
{
printf("xixi\n");
}
int Add(int x, int y)
{
return x + y;
}
int main()
{
void (*p1)() = &test;
void (*p2)() = test;
int (*p3)(int x, int y) = &Add;
int (*p4)(int, int) = Add;
return 0;
}
以 int (*p3)(int x, int y) 为例。
- (*p3) ，说明 p3 是一个 指针变量 ；
- int ，说明该函数指针变量指向的函数，其 返回类型 是 int 类型；
- (int x, int y) ，说明该函数指针变量指向的函数，其参数有2个，返回类型分别是： int 、 int 。
其中， x 和 y 可以省略不写。
4.2、使用
比如，用指针调用加法函数
#include<stdio.h>
int Add(int x, int y)
{
return x + y;
}
int main()
{
int (*p1)(int, int) = Add;
printf("%d\n", (*p1)(2, 3));
printf("%d\n", p1(3, 5));
return 0;
}
我们知道，在上面代码中， * 解引用操作符是用来找到函数的。
但是，上面代码中，加与不加 * ，都能实现加法操作。为什么？
原来，编译器是不会理会这段代码中的 * 的。但是，加上 * 有利于理解。
4.3、两段代码，以及 typedef 关键字
4.3.1、代码1
第一段代码
#include<stdio.h>
int main()
{
(*(void (*)())0)();
return 0;
}
我们来抽丝剥茧。
void (*)() ，这是一个函数指针变量的变量类型。
在这里， * 并未与 void (*)() 结合。所以我们看到 (void (*)())0 。不难想到，这里是将 int 类型的 0 ，强制类型转换为 void (*)() 类型的 0 ，也就是说此时0变成了地址。
(*(void (*)())0)() ，就是调用了这个地址，这个地址指向的是一个函数。
总结一下，这段代码的意思是：
- 调用了 0 地址处的函数，这个函数的类型是 void() 类型，没有参数。
4.3.2、代码2
第二段代码
#include<stdio.h>
int main()
{
void (*signal(int, void (*)(int)))(int);
return 0;
}
还是老样子， * 未与 signal 结合，就看 signal(int, void (*)(int)) 。这看上去应该是函数，并且是函数的声明。因为这里并未传入具体值，不是函数调用；也没有 {} ，不是函数定义。
这里声明了 signal 函数，其参数类型： int 、 void (*)(int) 。其中一个参数类型是函数指针变量类型的，类型是 void (*)(int) 。这个参数的指向对象是 void (int) 类型的函数。
如果我们在整段代码中，把 signal(int, void (*)(int)) 去了，剩下 void (*)(int) ，又是函数指针变量类型。
总结一下，这段代码的意思是：
- 声明了一个函数，函数名为 signal ，函数的返回类型为 void (*)(int) ，函数参数有2个，类型分别为 int 、 void (*)(int) 。
照着上面这么一说，这段代码应该是写成这个样子喽：
- void (*)(int) signal(int, void (*)(int))
遗憾的是，上面这样写，是错的。
代码2太复杂了，有什么办法能简化一下吗？答案是 typedef 关键字。
4.3.3、 typedef 关键字
typedef 是用来给类型重命名（重定义的）。
比如简化无符号整型：
#include<stdio.h>
int main()
{
typedef unsigned int uint;
uint a = 10;
return 0;
}
简化指针类型：
#include<stdio.h>
int main()
{
typedef int* pint;
int a = 10;
pint pa = &a;
return 0;
}
这里简化指针有一个很巧妙的用途。
#include<stdio.h>
int main()
{
int* p1, p2;
return 0;
}
上面代码中， int* 类型是给 p1 的，不是给 p2 的。而利用 typedef 就很好的解决了这一点。
但是有两个例外：
1、数组指针
比如我们想将 int (*)[ 5 ] 简化为 parr_t ，parr_t 就需要写在 * 的后面：
#include<stdio.h>
int main()
{
typedef int (*parr_t)[5];
int arr[5] = { 0 };
parr_t parr = &arr;
return 0;
}
2、函数指针
比如将 void (*)(int) 简化为 pf_t ，方法同数组指针：
#include<stdio.h>
void test(int x)
{
printf("nonono");
}
int main()
{
typedef void (*pf_t)(int);
pf_t p1 = test;
return 0;
}
所以，代码2可以进行简化：
#include<stdio.h>
int main()
{
typedef void (*pf_t)(int);
pf_t signal(int, pf_t);
return 0;
}
4、函数指针数组
4.1、创建
存放一个函数的地址，我们用函数指针；那么存放多个函数的地址，用什么呢？
答案是 函数指针数组 。
概念：
- 函数指针数组，是指针数组的一种，存放的是函数的地址。
格式：
#include<stdio.h>
int Add(int x, int y)
{
return x + y;
}
int Sud(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 (*parr[4])(int, int) = { Add, Sud, Mul, Div };
return 0;
}
- 在 int (*parr[4])(int, int) 中， parr 先与 [ 4 ] 结合，说明它是数组， parr 是数组名。
- 然后， int (*)(int, int) ，我们知道，这是函数指针变量的类型。
- 在大括号里写入函数名，以传入函数的地址。
用途：
调用函数。
#include<stdio.h>
int Add(int x, int y)
{
return x + y;
}
int Sud(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 (*parr[4])(int, int) = { Add, Sud, Mul, Div };
for (int i = 0; i < 4; i++)
{
int ret = parr[i](9, 3);
printf("%d\n", ret);
}
return 0;
}
4.2、应用：转移表
函数指针数组的应用：转移表。
比如，我们来简单实现计算器的功能。
还没有学习函数指针数组时，我们可能会这样写：
#include<stdio.h>
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;
do
{
menu();
printf("请输入：");
scanf("%d", &input);
switch (input)
{
case 1:
printf("请输入两个参数：");
scanf("%d %d", &x, &y);
ret = Add(x, y);
printf("%d\n", ret);
break;
case 2:
printf("请输入两个参数：");
scanf("%d %d", &x, &y);
ret = Sub(x, y);
printf("%d\n", ret);
break;
case 3:
printf("请输入两个参数：");
scanf("%d %d", &x, &y);
ret = Mul(x, y);
printf("%d\n", ret);
break;
case 4:
printf("请输入两个参数：");
scanf("%d %d", &x, &y);
ret = Div(x, y);
printf("%d\n", ret);
break;
case 0:
printf("退出。\n");
break;
default:
printf("输入错误，请重新输入。\n");
break;
}
} while (input);
return 0;
}
这样写确实能实现功能，但是这段代码里有两个问题：
- 1、 case 0 ~ 4 代码样式几乎一致，代码显得冗余。
- 2、如果我们要另外添加计算法则，不仅要多写函数的定义，还要多写 case 及相同样式的代码。这样，既浪费时间，又是代码显得更加冗余。
这时，函数指针数组，就派上了用场。
#include<stdio.h>
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;
do
{
menu();
printf("请输入：");
scanf("%d", &input);
if (0 == input)
{
printf("退出。\n");
}
else if (input >= 1 && input <= 4)
{
int (*p[5])(int, int) = { NULL, Add, Sub, Mul, Div };
// 下标对应 0 1 2 3 4
printf("请输入两个参数：");
scanf("%d %d", &x, &y);
ret = p[input](x, y);
printf("%d\n", ret);
}
else
{
printf("输入错误，请重新输入。\n");
}
} while (input);
return 0;
}
这里 int (*p[5])(int, int) = { NULL, Add, Sub, Mul, Div }; 就相当于转移表。因为一旦定义了创建了这个函数指针数组并传入一组函数的地址，我们就可以通过下标，来调用其中的一个函数。
这样一来，代码简洁了许多；同时，我们要另外添加计算法则时，只需添加函数，和修改部分参数即可。
扫一扫
1万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
