当前位置：首页 > news >正文

指针（4）

news 2025/9/5 10:37:12

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");//语句1elseprintf("str1 and str2 are not same\n");//语句2if(str3 == str4)printf("str3 and str4 are same\n");//语句3elseprintf("str3 and str4 are not same\n");//语句4return 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    4printf("请输入两个参数：");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 }; 就相当于转移表。因为一旦定义了创建了这个函数指针数组并传入一组函数的地址，我们就可以通过下标，来调用其中的一个函数。

这样一来，代码简洁了许多；同时，我们要另外添加计算法则时，只需添加函数，和修改部分参数即可。

查看全文

http://www.dtcms.com/a/367243.html