目录
通过深入理解指针(1)和深入理解指针(2),我们对指针有了一个初步的了解,学会了一级指针、二级指针、指针数组……而深入理解指针(3),主要是为了学习不同数据类型的指针变量。
一、字符指针变量
字符串指针变量的指针类型为char*,下面我们通过这段代码来解析字符指针变量。
int main()
{
printf("指针接收字符\n");
char ch = 'w';
char* pc = &ch;
printf("\t*pc=%c\n", *pc);
printf("----------------\n");
printf("指针接收字符串\n");
const char* pstr = "abcdef";//const 加了一层保护,使其变成常量字符串,被修改编译器会报错
printf("\t*pstr=%c\n", *pstr);//其实是把字符串的首字符地址放到pstr,字符串出现在表达式中时,他的值就是第一个字符的地址
printf("\tpstr=%s\n", pstr); //%s占位符的特点就是只要告诉他字符串的首地址, 就可以读取整个字符串
printf("\tpstr[3]=%c\n", pstr[3]);//[]是特殊的解引用操作符,等价于*(pstr+3),相当于得到第1个元素偏移3得到第四个元素
printf("\tabcdef[3] = % c\n", "abcdef"[3]);//可以把字符串想象成一个字符数组,可以通过下标去访问他
return 0;
}
指针接收字符
*pc=w
----------------
指针接收字符串
*pstr=a
pstr=abcdef
pstr[3]=d
abcdef[3] = d
字符指针变量,顾名思义就是指向字符的指针变量,所以利用指针接收字符的地址(第31行代码),最后解引用该指针变量得到的是对应的字符,非常容易理解。 但字符指针变量还有一种方式,就是接收字符串的地址。
通过第35行代码,我们用字符指针变量pstr接收了字符串“abcdef”,那这是把整个字符串放到pstr指针变量里面了吗?
其实并不是的,我们通过第36行代码的运行结果,发现将指针变量pstr解引用后得到的是‘a’,这说明字符指针变量pstr接收字符串的本质是将字符串的首字符地址存放到pstr中,所以如果字符串出现在表达式中,他的值就是第一个字符的地址。
既然pstr存放的是字符串首字符的地址,那么我们打印出来的是一个地址,但我们在看向第37行代码,当我们用%s的占位符时,却可以直接将整个字符串打印出来,这说明了%s占位符的特点就是只要告诉他字符串首字符的地址,他就可以直接读取整个字符串。
那为什么,我们知道了字符串的首元素地址,就可以通过%s打印出字符串全体呢?这是因为其实我们可以把字符串理解成一个字符数组,他具有数组的特点,可以通过首元素地址找到后面的全部元素,并且也可以像数组一样通过下标去访问每个元素,比如我们想访问字符串下标为3的元素(d),那么通过第39行代码我们可以发现“abcdef”[3]是可行的,
既然可以通过下标去访问字符串,那么既然pstr是接收字符串的指针变量,那么我们同样可以通过首元素地址的指针偏移来找到下标为3的元素,第38行代码中的pstr[3](等价“*(pstr+3)”)也是可行的。
下面是一道和字符串相关的面试题。
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;
}
str1 and str2 are not same
str3 and str4 are same
为什么str1和str2的地址不同,而str3和str4的地址相同呢??
将常量字符串赋值给数组(str1和str2),本质上是将这个常量字符串复制一份到数组中,这两个数组其实并不在一个空间,所以str1=str2,并且复制出来的常量字符串是可以修改的。
而如果通过字符指针变量指向常量字符串(str3和str4),对于常量字符串来说,是只能读不能改的,从内存利用率来说,内容相同的字符串只会保存一份,所以str3=str4.
二、数组指针变量
我们学过指针数组,它是一个存放指针的数组。
那什么是数组指针变量呢?我们通过已经学过的指针变量来类比一下。
所以数组指针变量是一个存放的是数组的地址,并且能够指向数组的指针变量。
int* p1[10];
int(*p2)[10];
以上哪个是数组指针变量呢?
对于int*p1[10]来说,首先p1会先和[ ]结合,然后int和*结合,所以p1有10个元素,并且每个元素是int*类型,所以p1是一个存放指针的数组,p1是指针数组。([ ]的优先级高于*)
对于int(*p2)[10]来说,p2先和*结合了,所以*p2是一个指针,int和[10]代表p2指向的是一个数组,并且有10个元素,并且每个元素的类型是int,所以p2是数组指针。(因为[ ]的优先级高于*,所以必须加上( )来保证p和*先结合)
那数组指针如何初始化呢?既然指针变量是用来存放数组地址的,而&arr是取整个数组的地址,所以写法就是int(*p2)[10]=&arr。
三、二维数组传参的本质
数组指针有什么用呢?其实数组指针有自己的应用场景,在此之前要先了解二维数组传参的本质
以往我们对有一个二维数组需要传递给函数时,我们是这样写的
void test(int a[][5], int r, int c)
{
int i = 0;
int j = 0;
for (i = 0; i < r; i++)
{
for (j = 0; j < c; j++)
{
printf("%d ", p[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;
}
1 2 3 4 5
2 3 4 5 6
3 4 5 6 7
形参和实参都是二维数组的形式,但其实还有其他写法。
对于二维数组来说,可以看做是每个元素是一维数组的数组,也就是二维数组的每个元素是一个一维数组。那么二维数组的首元素就是第一行,是个一维数组。
根据一维数组的数组名名就是首元素地址、一维数组传参本质是传递首元素地址这个规则,我们可以推出二维数组的数组名就是就是第一行(一维数组)的地址,二维数组传参本质是传递第一行这个一维数组的地址。
根据上面的代码,我们知道该二维数组第一行的一维数组的数据类型是int[5],所以第一行的地址类型就是数组指针类型int(*)[5],所以我们可以将形参类型写成指针形式。
接下来对上面的代码进行改写,将形参写成数组指针类型。
void test(int(*p)[5], int r, int c)
{
int i = 0;
int j = 0;
for (i = 0; i < r; i++)
{
for (j = 0; j < c; j++)
{
printf("%d ",p[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;
}
1 2 3 4 5
2 3 4 5 6
3 4 5 6 7
怎么去理解*(*(p+i)+j))呢?我们要进行拆解!(假设访问二维数组中的一个元素)
首先是p+i,二维数组的首元素地址是第一行的一维数组,所以p存放的是第一行的地址,所以+i会跳过i行,i=0时,此时跳过0行,拿到的是第一行的地址,i=1时,跳过1行,拿到的是第二行的地址,i=2时,跳过2行,拿到的是第三行的地址。
然后是*(p+i),假设i已经确定,此时就是通过解引用拿到了一行的数据。
然后是*(p+i)+j,此时*(p+i)已经拿到一行的数据了,通过j来访问这一行的其他元素地址,当j=0时,就是首元素地址,j=1时,就跳过一个元素,拿到第二个元素的地址,以此类推,找到了该行所有元素的地址。
然后是*(*(p+i)+j)),假设j已经确定,此时*(p+i)+j就是一个元素的地址,再对他进行解引用,找到该元素。
底层逻辑还是通过指针的偏移量去访问每个元素。所以p[i][j]的写法也是可行的。
所以根据二维数组传参的本质-----传递首行这个一维数组的地址,我们找到了数组指针变量的应用场景。
四、函数指针变量
4.1 函数指针变量
通过类比,函数指针就是指向函数的指针,那么函数指针变量就是用来存放函数的地址。
对应数组arr来说,arr是数组首元素地址,而&arr代表是整个数组的地址,而对于函数来说,函数名是函数的地址,&函数名也是函数的地址。
既然函数指针变量是用来存放函数的地址的,所以未来也可以通过函数的地址去调用函数。
函数指针怎么创建?
int(*p)(int, int) = Add;
int(*p)(int x, int y) = &Add;
( )将*和p结合起来,说明这是一个指针,(int,int)说明这个指针指向一个函数,并且形参类型是int和int,开头的int说明该函数的返回类型是int。
add和&add是一样的,因为对于函数来说,函数名是地址,&函数名也是地址
同理*p和p也是一样的,函数指针变量是可以不需要解引用。
形参的形参名可写可不写
int (*pf3) (int x, int y)
| | ————————————————
| | |
| | pf3指向函数的参数类型和个数交代
| 函数指针变量名
pf3指向函数的返回类型
int (*)(int x, int y)//pf3函数指针变量的类型
4.2 函数指针变量的使用
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;
}
5
8
注意:因为Add和&Add都是函数的地址,所以对于pf3来说,即使不解引用也是可以调用函数的,但如果解引用了,一定要记得用括号( )将*和pf3放在一起!!
4.3 函数指针变量的拓展
fun1(char* p, int (*)(char*));
(*(void (*)())0)();
void (*signal(int, void(*)(int)))(int);
分析这3个代码
1.fun1的的第1个形参的类型是字符指针,第2个形参int(*)(char*),(*)代表这个形参是个指针,int和(char*)表名这是一个函数指针,形参类型为字符指针,返回值为整型。函数指针作为其他函数的形参时,其自身的函数名和形参名可以省略,仅保留数据类型即可。
2.多个括号要逐步拆解,void(*)( )说明这是一个void类型的函数指针,没有形参,类型放在(),就是强制类型转换,所以(void(*)( )0)的意思时将0这个整数值强制转换成一个void(*)( )类型的函数指针,再进行解引用,得到的是函数指针的地址,结尾的( )就是调用0地址处的函数。所以上述代码实际上是一个函数调用,将0转化成一个void(*)( )类型的函数地址,再去调用0地址处的函数。
3.首先,*没有和signal在一起,signal(int,void(*)(int))说明signal是一个函数名,该函数的形参有两个类型,一个是int,一个是void(*)(int)类型的函数指针,剩下的部分就是该函数的返回类型,所以signal的返回类型是void(*)(int)类型的函数指针。上述代码其实是一个函数声明。
通过上述的扩展,我们复习到了
1.认识函数指针类型
2.强制类型转换
3.通过函数指针调用函数的方式
4.函数的定义、声明、调用
4.4 typedef关键字
typedef是用来类型重命名的,可以将复杂的类型简单化
typedef unsigned int uint;
//将unsigned int 重命名为uint
typedef int* ptr_t;//整形指针
//int*重命名为ptr_t
typedef int(*parr_t)[5];//数组指针
//int(*5)重命名为parr_t
typedef void(*pfun_t)(int);//函数指针
//void(*)(int)重名名为pfun_t
void (*signal(int, void(*)(int)))(int);//进行改写
pfun_t signal(int, pfun_t);
关于typedef,常规写法是 typedef 类型 重命名 ,但是对于数组指针类型和函数指针类型稍有区别,重命名部分要写在*的后面。
五、函数指针数组
数组是一个存放相同类型数据的存储空间,所以函数指针数组存放的是具有相同返回类型和形参的函数指针。
函数指针数组怎么创建呢?
int (*parr1[3])();
int* parr2[3]();
如上图代码,其实是parr1,首先parr1先和[ ]结合,说明parr1是个数组,且有3个元素,存放的是int(*)()类型的函数指针。
函数指针数组的应用场景,我们可以通过转移表来理解。
六、转移表的应用
函数指针数组,用数组取每个元素的方式去调用函数,就叫转移表。
当我们想要对两个数进行加减乘除运算操作时,以下是计算机的一般实现。
#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;
}
假设我们想要对这两个数进行更多的运算,那么由于增加了更多的选择,switch语句的相关代码会变得非常冗长,且重复性很高,所以此时用函数指针数组,可以很好地解决这个问题。下面我们通过函数指针数组来实现。
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;
}
我们发现原本通过switch语句的选择代码,直接变成了函数指针数组的下标访问,代码简洁清晰。
为什么可以使用函数指针数组?因为add、sub、mul、div这四个函数的形参以及返回类型是意义的,所以他们的函数指针类型也是一致的,根据数组只能存放相同数据类型的特点,所以这几个函数可以被放在一个函数指针数组里,当放进函数指针数组时,我们就可以通过下标去访问并调用对应的函数!