一.字符指针变量
在指针的类型中,我们知道有一种指针类型为字符指针char *
一般使用:
#include<stdio.h>
int main()
{char ch = 'a';char* p = &ch;*p = 'b';printf("%c\n",ch);return 0;
}
其实还有一种使用方式 :
#include<stdio.h>
int main()
{const char* pstr = "hello world";printf("%s",pstr);return 0;
}
这里是把一个字符串放到了pstr的指针变量里了吗?
其实不是,本质上是将字符串的首字符的地址放到了pstr中。
- 我们知道指针变量的大小其实是4/8字节,而字符串却不是,所以是不可能将字符串存放到pstr中的。
-
#include<stdio.h> int main() {char* pstr = "hello world";printf("%c",*pstr);return 0; }
在解引用后我们会发现打印的是h,也就是将字符串中首字符h的地址存放到了指针中
- 在我们学习指针运算时,指针+-整数,会根据指针的类型跳过不同的字节,这里其实也可以用于证明:
#include<stdio.h> int main() {char* pstr = "hello world";printf("%s",pstr+5);return 0; }
因为pstr的类型是char*,所以+5会跳过五个字节从而只打印了后面的world。这也证明了pstr储存的就是首字符的地址。
#include<stdio.h>
int main()
{char* pstr = "hello world";*pstr = 'abc';printf("%s",pstr);return 0;
}
虽然这个代码在编译的时候并不会报错,但是程序运行时会崩溃。为什么呢?
因为“hello world”是常量字符串,常量字符串是不能修改的。所以pstr实际的类型应该是
const char* pstr = "hellon world";
//这里的const可写可不写
虽然不可以修改但是我们可以使pstr指向另一个常量字符串,起到修改的作用。
#include<stdio.h>
int main()
{char* pstr = "hello world";pstr = "abcdef";printf("%s",pstr);return 0;
}
这里打印出来的结果是abcdef;
看一道题:
#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相同的原因:这⾥str3和str4指向的是⼀个同⼀个常量字符串。C/C++会把常量字符串存储到单独的⼀个内存区域,当⼏个指针指向同⼀个字符串的时候,他们实际会指向同⼀块内存,并不会开辟两次空间。
二.数组指针变量
指针数组是一种数组,数组中存放的是指针(地址)。
那么数组指针到底是数组?还是指针呢?
答案肯定是一种指针变量。
我们熟悉的指针变量:
- 整形指针变量:int* pint;存放的是整形变量的地址,能够指向整形数据的指针。
- 浮点数指针变量:float* pf;存放的是浮点型变量的地址,能够指向浮点数据的指针。
那么数组指针变量 :存放的是数组的地址,能够指向数组的指针变量。
思考一下:p1和p2到底是什么???
int *p1[10];
int (*p2)[10];
p1毫无疑问是一个数组 ,*的优先级小于[ ],所以p1先与[10]结合,所以它先是一个数组,数组元素的类型是int*,所以它是一个指针数组。
那么p2就是数组指针了,因为()的优先级很高,可以用于更改其他操作符的优先级,所以p2先和*结合,代表它是一个指针,指针所指向的是一个大小为10的整形数组。
数组指针如何初始化呢?
int arr[10] = { 0 };
int (*p)[10] = &arr;
&arr和p的类型是一模一样的。
int (*p)[10] = &arr;
//int指的是p所指向的数组的元素的类型。
//*指p是一个指针变量。
//[10]指的是p所指向的数组的大小。
三.二维数组传参的本质
观察下面这个代码:
#include <stdio.h>
void test(int a[3][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 ", 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] 。那就意味着⼆维数组传参本质上也是传递了地址,传递的是第一⾏这个⼀维数组的地址,那么形参也是可以写成指针形式的。
所以test函数就可以这样写。
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");}
}
我们可以发现参数不仅改了,printf函数中的参数也有所变化。
*(*(p + i) + j);
p是第一行的地址,p+i就可以得到第二行或者第三行的地址。
再解引用就是一维数组首元素的地址,加j就可以得到不同位置元素的地址,
再解引用就可以得到该元素。
总结:⼆维数组传参,形参的部分可以写成数组,也可以写成数组指针的形式。
四.函数指针变量
(1)函数指针变量的创建。
通过前面的学习,我们类比可得知,函数指针变量存放的就是函数的地址,也就是指向一个函数。
函数是否有地址呢?
我们可以运行一下这个代码。
#include<stdio.h>
int Add(int x,int y)
{return x + y;
}
int main()
{printf("%p\n",Add);printf("%p\n",&Add);return 0;
}
输出结果:
Add和&Add结果是一样的,也就是说函数名就是函数的地址,当然我们也可以&函数名来获取函数的地址。
那么我们应该如何书写这个指针变量呢?
int (*pf)(int,int) = &Add;
int (*pf)(int x,int y) = Add;//;x和y可写可不写
如何理解这个呢?其实和数组指针是类似的
int (*pf3) (int x, int y)
| | ------------
| | |
| | pf3指向函数的参数类型和个数的交代
| 函数指针变量名
pf3指向函数的返回类型
int (*) (int x, int y) //pf3函数指针变量的类型
#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));//输出结果5printf("%d\n", pf3(3, 5));//输出结果8return 0;
}
观察两个有趣的代码:
代码1:
(*(void (*)())0)();
代码2:
void (*signal(int , void(*)(int)))(int);
代码1理解:
- (void (*)( )) ,是一个返回值为void,参数为空的函数指针原型。
- (void (*)( ))0,把0强制类型转换为一个返回值为void,参数为空的函数指针,指针指向的地址为0.
- *(void (*)( ))0,前面加上*表示整个是一个返回值为void的函数的名字
- (*(void (*)( ))0)( ),这当然就是一个函数了。
代码2理解:
- void(*)(int)就是一个函数指针,这个函数的返回值为void,参数只有一个int.
- signal是这个函数名,它的参数就是int和void(*)(int).
- 返回值也是一个函数指针void(*)(int),只不过signal作为函数名写在了*后面。
(2)typedef关键字
typedef关键字使用类型重命名的,可以简化复杂的类型。
比如unsigned int 你觉得写起来不方便就可以这样写。
typedef unsigned int u_int;
int main()
{u_int a = 10;
}
这里就将unsigned int 重命名为了u_int;
指针也可以重命名。
typedef int* ptr_t;
但是对于函数指针和数组指针有一点不一样。
typedef int(*parr_t)[5]; //新的类型名必须写在*的后面
typedef void(*pfun_t)(int);
代码简化就可以这样写:
typedef void(*pfun_t)(int);
pfun_t signal(int, pfun_t);
五.函数指针数组
什么是函数指针数组呢?
首先,函数指针数组肯定是一个数组,存放的是函数的地址。
那么函数指针的数组如何定义呢?
int (*parr1[3])();
int *parr2[3]();
int (*)() parr3[3];
答案是第一个。
parr1首先和[ ]结合,证明它是一个数组,然后是类型为int (*)()的函数指针。虽然第三个也是这样的,但是parr3[3]的位置不对,应该放在*后面。
六.转移表
#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;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;
}