文章目录

  • 1. 字符指针
  • 2. 指针数组
  • 3. 数组指针
    • 3.1 数组指针的定义
    • 3.2 &数组名VS数组名
    • 3.3 数组指针的使用
  • 4. 数组参数、指针参数
    • 4.1 一维数组传
    • 4.2 二维数组传参
    • 4.3 一级指针传参
    • 4.4 二级指针传参
  • 5. 函数指针
  • 6. 函数指针数组
  • 7. 指向函数指针数组的指针

1. 字符指针

在指针的类型中我们知道有一种指针类型为字符指针char* ;
一般使用:

int main(){char ch = 'w';char* pc = &ch;//pc就是字符指针char*p = "abcdef";//是把字符串首元素的地址存放在p中//"abcdef"为常量字符串不能修改return 0;}

当p被修改时，程序会陷入死循环，并且调试过程可以看到错误所在

那我们要怎样对p进行修改呢？

把”abcdef”放在一个char 类型的数组中，chsr*p=arr指向的是数组的首元素，而数组的首元素是可以被修改的

所以对代码做如下修改：

#include int main(){char ch = 'w';char* pc = &ch;char arr[] = "abcdef";char* p = arr;*p = 'w';printf("%s\n", arr);return 0;}

打印结果：

注：

有些编译器在运行时会报警告，让你在char*p = “abcdef”前加const，加上const如果在想用第一种方法修改p编译器会报错


所以字符指针还有另一种写法

#include int main(){const char* pstr = "hello bit.";printf("%s\n", pstr);return 0;}

运行结果;

下面看一道面试题：

#include 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");elseprintf("str1 and str2 are not same\n");if (str3 == str4)printf("str3 and str4 are same\n");elseprintf("str3 and str4 are not same\n");return 0;}

输出结果：

这里str3和str4指向的是一个同一个常量字符串。C/C++会把常量字符串存储到单独的一个内存区域，当几个指针。指向同一个字符串的时候，他们实际会指向同一块内存。但是用相同的常量字符串去初始化不同的数组的时候就会开辟出不同的内存块。所以str1和str2不同，str3和str4不同。

2. 指针数组

指针数组 是数组 是一种存放指针的数组

类比法理解

看代码：

#include int main(){char* arr[] = { "abcdef","hehe","qwer" };int i = 0;for (i = 0; i < 3; i++){printf("%s\n", arr[i]);}return 0;}

存放内容画图表示

打印结果：

在看一个指针数组的用法

#include int main(){int arr1[] = { 1,2,3,4,5 };int arr2[] = { 2,3,4,5,6 };int arr3[] = { 3,4,5,6,7 };//arr[i]==*(arr+i)//arr是一个存放整形指针的数组int* arr[] = { arr1,arr2,arr3 };int i = 0;for (i = 0; i < 3; i++){int j = 0;for (j = 0; j < 5; j++){printf("%d ", arr[i][j]);//printf("%d ", *(arr[i]+j));  与arr[i][j]的打印结果一样}printf("\n");}return 0;}

运行结果：

3. 数组指针

数组指针 是指针 是一种指向数组的指针

3.1 数组指针的定义

数组指针是指针？还是数组？
答案是：指针。
我们已经熟悉：
整形指针：
int * pint; 能够指向整形数据的指针。
浮点型指针：
float * pf; 能够指向浮点型数据的指针。 那数组指针应该是：能够指向数组的指针。

下面代码哪个是数组指针？

int *p1[10];int (*p2)[10];//p1, p2分别是什么？

解释：

int (*p)[10];//解释：p先和*结合，说明p是一个指针变量，然后指着指向的是一个大小为10个整型的数组。//所以p是一个指针，指向一个数组，叫数组指针。//这里要注意：[]的优先级要高于*号的，所以必须加上（）来保证p先和*结合。

看一个例子：

int * arr [5] 的数组指针是什么？
int * (*p) [5] = &arr

3.2 &数组名VS数组名

arr 和 &arr 分别是什么？
我们知道arr是数组名，数组名表示数组首元素的地址。
那&arr数组名到底是什么？
我们看一段代码：

#include int main(){int arr[10] = { 0 };printf("%p\n", arr);//%p打印地址printf("%p\n", &arr);printf("%p\n", &arr[0]);return 0;}

运行结果如下：

数组名绝大部分情况下是数组首元素的地址
但是有2个例外：

  1. sizeof(数组名) – sizeof内部单独放一个数组名的时候，数组名表示的整个数组，计算得到的是数组的总大小
  2. &arr – 这里的数组名表示整个数组，取出的是整个数组的地址,从地址值的角度来讲和数组首元素的地址是一样的，但是意义不一样

可见数组名和&数组名打印的地址是一样的。
难道两个是一样的吗？
我们再看一段代码：

#include int main(){int arr[10] = { 0 };printf("%p\n", arr);//int*取出的地址类型printf("%p\n", arr + 1);//4printf("%p\n", &arr[0]);//int*取出的地址类型printf("%p\n", &arr[0]+1);//4printf("%p\n", &arr);//int(*)[10]取出的地址类型printf("%p\n", &arr + 1);//跳过整个数组，大小为40return 0;}

运行结果：

根据上面的代码我们发现，其实&arr和arr，虽然值是一样的，但是意义应该不一样的。
实际上： &arr表示的是数组的地址，而不是数组首元素的地址。（细细体会一下）
本例中 &arr 的类型是： int(*)[10] ，是一种数组指针类型数组的地址+1，跳过整个数组的大小，所以 &arr+1 相对于 &arr 的差值是40

3.3 数组指针的使用

那数组指针是怎么使用的呢？
既然数组指针指向的是数组，那数组指针中存放的应该是数组的地址。
看代码：
下标的方式来访问数组

#include int main(){int arr[] = { 1,2,3,4,5,6,7,8,9,10 };int i = 0;int sz = sizeof(arr) / sizeof(arr[0]);for (i = 0; i < sz; i++){printf("%d ", arr[i]);}return 0;}

指针的方式访问数组

#include int main(){int arr[] = { 1,2,3,4,5,6,7,8,9,10 };int i = 0;int sz = sizeof(arr) / sizeof(arr[0]);int* p = arr;for (i = 0; i < sz; i++){printf("%d ", *(p + i));}return 0;}

运行结果：

一个数组指针的使用：

#include //一维数组传参，形参是数组void print1(int arr[10], int sz){int i = 0;for (i = 0; i < sz; i++){printf("%d ", arr[i]);}printf("\n");}//一维数组传参，形参是指针void print(int *arr, int sz){int i = 0;for (i = 0; i < sz; i++){//printf("%d ", arr[i]);printf("%d ", *(arr+i));}printf("\n");}int main(){int arr[10] = {1,2,3,4,5,6,7,8,9,10};int sz = sizeof(arr) / sizeof(arr[0]);print(arr, sz);return 0;}

运行结果;

4. 数组参数、指针参数

4.1 一维数组传

#include void test(int arr[])//ok" />
 
4.2 二维数组传参
 
void test(int arr[3][5])//ok？ {}void test(int arr[][])//ok？—— no {}void test(int arr[][5])//ok？ {}  //总结：二维数组传参，函数形参的设计只能省略第一个[]的数字。  //因为对一个二维数组，可以不知道有多少行，但是必须知道一行多少元素。  //这样才方便运算。void test(int *arr)//ok？—— no {}void test(int* arr[5])//ok？—— no {}void test(int (*arr)[5])//ok？ {}void test(int **arr)//ok？—— no {}int main(){    int arr[3][5] = {0};    test(arr);}
4.3 一级指针传参
代码演示：
#include void print(int* p, int sz){int i = 0;for (i = 0; i < sz; i++){printf("%d\n", *(p + i));}}int main(){int arr[10] = { 1,2,3,4,5,6,7,8,9 };int* p = arr;int sz = sizeof(arr) / sizeof(arr[0]);//一级指针p，传给函数print(p, sz);return 0;}
运行结果：
 
 思考：
当一个函数的参数部分为一级指针的时候，函数能接收什么参数？
4.4 二级指针传参
代码演示：
#include void test(int** ptr){printf("num = %d\n", **ptr);}int main(){int n = 10;int* p = &n;int** pp = &p;test(pp);test(&p);return 0;}
运行结果：
 
 思考：
当函数的参数为二级指针的时候，可以接收什么参数？
5. 函数指针
类比：
 
数组指针中存放的时数组的地址
 函数指针中存放的应该是函数的地址
 那么函数有地址吗？
让我们看一段代码
#include void test(){printf("hehe\n");}int main(){printf("%p\n", test);printf("%p\n", &test);return 0;}
运行结果：
 
 注：
函数名 与 &函数名 都是函数的地址，没有任何区别
那我们的函数的地址要想保存起来，怎么保存？
 下面我们看代码：
#include  int Add(int x, int y){return x + y;}int main(){    //pf就是函数指针int (* pf)(int, int) = Add;//函数的地址要存起来，就得放在【函数指针变量】中int ret = (*pf)(3, 5);printf("%d\n", ret);return 0;}
运行结果：
 
 阅读两段有趣的代码：
  • 代码1
#include int main(){//下面代码是一次函数调用(*( void (*)() ) 0)( );//void (*)()是一个函数指针类型//( void (*)() )强制类型转换return 0;}
  1. 将0强制类型转换为void (*)() 类型的函数指针
  2. 这就意味着0地址处放着一个函数，函数没参数，返回类型是void
  3. 调用0地址处的这个函数
  • 代码2
#include int main(){void ( * signal(int, void(*)(int)))(int);//void(*)(int)函数指针类型//signa是函数名，(int, void(*)(int))是函数的参数return 0;}
上述的代码是一个函数的声明
 函数的名字是signal
 signal函数的参数第一个是int类型，第二个是void(*)(int)类型的函数指针
 该函数指针指向的函数参数是int，返回类型是void
 signal函数的返回类型也是一个函数指针
 该函数指针指向的函数参数是int，返回类型是void
代码2太复杂，如何简化：
typedef void(*pf_t)(int);//将void(*)(int)类型重新起个别名叫pf_tpf_t signal(int, pf_t);
6. 函数指针数组
数组是一个存放相同类型数据的存储空间，那我们已经学习了指针数组，
 比如：
int *arr[10];//数组的每个元素是int*
那要把函数的地址存到一个数组中，那这个数组就叫函数指针数组，那函数指针的数组如何定义呢？
int (*parr1[10])();//parr1 先和 [] 结合，说明 parr1是数组，//数组的内容是 int (*)() 类型的函数指针
代码演示：
#include 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 (* pf[4])(int, int) = {Add, Sub, Mul, Div};int i = 0;for (i = 0; i < 4; i++){int ret = pf[i](8, 4);printf("%d\n", ret);}return 0;}
运行结果：
 
函数指针数组的用途：转移表
 例子：（计算器）
#include 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;}void menu(){printf("******************************\n");printf("****   1. add    2.sub   *****\n");printf("****   3. mul    4.div   *****\n");printf("****   0. exit           *****\n");printf("******************************\n");}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;}
使用函数指针数组的实现：
#include 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;}void menu(){printf("******************************\n");printf("****   1. add    2.sub   *****\n");printf("****   3. mul    4.div   *****\n");printf("****   0. exit           *****\n");printf("******************************\n");}int main(){int input = 0;int x = 0;int y = 0;int ret = 0;//转移表 - 函数指针的数组int (*pfArr[])(int,int) = { NULL,Add,Sub,Mul,Div };do{menu();printf("请选择>");scanf("%d", &input);if (input == 0){printf("跳出计数器\n");break;}else if (input >= 0 && input <= 4){printf("请输入两个操作数：");scanf("%d %d", &x, &y);ret = pfArr[input](x, y);printf("%d\n", ret);}else{printf("选择错误\n");}} while (input);return 0;}
运行结果：
 
7. 指向函数指针数组的指针
指向函数指针数组的指针是一个 指针
 指针指向一个 数组 ，数组的元素都是 函数指针 ;
 如何定义？
void test(const char* str){printf("%s\n", str);}int main(){//函数指针pfunvoid (*pfun)(const char*) = test;//函数指针的数组pfunArrvoid (*pfunArr[5])(const char* str);pfunArr[0] = test;//指向函数指针数组pfunArr的指针ppfunArrvoid (*(*ppfunArr)[5])(const char*) = &pfunArr;return 0;}
好了，关于指针就先讲到这，我们下期在见，如果有什么问题可以在评论区留言或者私信七七的哦！