![](https://i-blog.csdnimg.cn/blog_migrate/2a3d27c5e4ac5f123fe6c11028c5aafc.gif)
前言🌊
谈到指针,想必大家都不陌生。它不仅是C语言的重难点,还是不少C初学者的噩梦。本期我们将深度探讨一些较为复杂的指针以及指针的妙用,带领大家感受指针的魅力😝。
首先,我们先来复习复习指针的概念:
1. 指针就是地址,而 指针变量是个变量,用来存放地址(指针),地址标识着一块唯一的内存空间。例如有一张纸,上面写着湖滨东路12号,那湖滨东路12号是什么呢?它就是一个地址,一个指针;而这个地址的载体纸便是指针变量,修改纸上的内容就相当于修改了指针变量存放的内容,即修改了指针。
2. 指针的大小是固定的 4/8个字节(32位平台/64位平台)。
3. 指针是有类型,指针的 类型决定了指针的+-整数的步长和指针解引用操作的时候的权限。
4.指针和指针不能进行加法运算,这是没有意义的;但可以进行 减法运算,运算的结果表示 间隔的元素个数。
下面,让我们怀着激动的心情,正式进入进入今天的主题✨
字符指针🌠
我们知道,指针有一种类型叫字符指针,我们一般有以下方法使用它:
//指向一个字符变量
int main()
{
char ch = 'c';
char* pch = &ch;
*pch = 'w';
return 0;
}
//指向一个字符串
int main()
{
const char* str= "abcdef";
printf("%s\n", str);
return 0;
}
对于第一种,毫无疑问,pch存放的是字符变量ch的地址。但是对于第二种,我们是将整个字符串放到str里面吗?实则不然,我们是将"abcdef"的首元素地址存放到str中。如下:
![](https://i-blog.csdnimg.cn/blog_migrate/99a605d98c0bfe5d8b5c11b71cf4c7da.png)
上述代码实际上是将"abcdef"中'a'的地址放到指针变量str中。有了这层理解,我们来看看下面一道面试题:
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;
}
代码运行的结果如下:
![](https://i-blog.csdnimg.cn/blog_migrate/cea4efec973ddb7642315e1e2ca28db2.png)
我们来分析以下:
对于 str1和str2想必大家没有问题,这两个数组都用"abcdef"来进行初始化,它们的 存放的内容一样。但是毕竟是两个不同的数组,它们 在内存中的地址是不同的,因此它们首元素的地址也是不同的,并且 数组名代表首元素地址,因此str1不等于str2。就好比定义变量a=10,变量b=10,虽然a == b,但是&a != &b。
而有疑问的可能是 str3和str4,这里需要注意的是,它们存放的都是字符串"abcdef"首元素的地址,而在C/C++中,一个常量字符串通常会单独存放在地址空间中的字符常量区,因此str3和str4指向的其实是同一块内存空间。如下:
![](https://i-blog.csdnimg.cn/blog_migrate/36477127a6de67fc22447abb9eee8123.gif)
指针数组与数组指针✈
3.1 引入
这两兄弟长得很像,很容易让初学者记混。我们需要记住指针数组是一个数组,它的每一个元素是指针;而数组指针是一个指针,它指向一个数组。
个人认为:无论名称多么复杂,后缀一般就是其类型。
试问下面几条语句表达什么:
int* arr[10];
int (*arr)[10];
int (*arr[10])[10];
对于第一条,arr毋庸置疑是变量名。首先arr会先和[]结合,因此arr是一个数组,一个每个元素是整形指针的指针数组。
对于第二条,arr与*号结合,因此arr是一个指针,指向一个整形数组,arr是一个数组指针。
对于第三条,同样由于[]的优先级比*号高,因此arr先与[]结合,arr是一个数组,每个元素的类型是int (*)[10],即是一个整形数组指针。综上,arr是一个存放整形数组指针的数组。
如果你想,你甚至可以无限套娃下去,这里就留给读者自己尝试啦 💪
3.2 使用方法
对于数组指针,既然它是指向数组的,那数组指针中存放的应该是数组的地址,我们来看如下代码:
int main()
{
int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };
int(*p1)[10] = &arr;//正确?错误?
int(*p2)[10] = arr; //正确?错误?
return 0;
}
我们知道数组名arr代表首元素地址,但也有两个例外,分别是&数组名和sizeof(数组名),这两种情况下arr代表的就不是首元素地址了,而是整个数组。因此,p1才是正确的使用方法。
我们可以通过数组指针将一个数组的地址保存起来,不过我们很少这样写代码,数组指针一般用在数组传参上,如下:
void print_arr1(int arr[3][5], int row, int col) //形参用数组的形式接收
{
for (int i = 0 ; i < row; i++)
{
for (int j = 0; j < col; j++)
{
printf("%d ", arr[i][j]);
}
printf("\n");
}
}
void print_arr2(int(*arr)[5], int row, int col) //形参用指针的方式接收
{
for (int i = 0; i < row; i++)
{
for (int j = 0; j < col; 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_arr1(arr,3,5);
print_arr2(arr, 3, 5);
return 0;
}
首先,将一个二维数组当作参数传递,用一个二维数组来接收想必都没有异议。有疑问的可能是print_arr2,为什么我们可以用一个一维数组指针来接收呢?
事实上, 数组传参是会发生降维的,降维成 指向其内部元素类型的指针。 如果不降维,就要发生数组拷贝,数组空间过大,函数调用效率降低,因此需要降维。如二维数组传参,就会降维成指向一维数组的指针。
而我们可以 把二维数组看作一个一维数组,数组中的每一个元素都为一个 一维整形数组。那么二维数组arr传参,发生降维后传的就是首个整形数组的地址,因此可以 用一维整形数组指针来接收。
而对于指针数组,其存放的就为一个个指针变量,如下:
int main()
{
char* s1 = "hello";
char* s2 = "world";
char* arr[2] = { s1,s2 };
for (int i = 0; i < 2; i++)
{
printf("%s ", arr[i]);
}
return 0;
}
4. 数组/指针传参🌟
我们在写代码的时候难免要将数组或者指针作为参数传递给函数,下面我们就来介绍以下如何正确地设计函数参数。
4.1一维数组传参
void test01(int arr[10]) {}; //1 ok?
void test01(int arr[]) {}; //2 ok?
void test01(int* arr) {}; //3 ok?
void test02(int* arr[10]) {}; //1 ok?
void test02(int** arr) {}; //2 ok?
int main()
{
int arr1[10] = {0};
int* arr2[10] = { 0 };
tesst01(arr1);
test02(arr2);
return 0;
}
对于 tesst01(),arr1是一个一维整形数组,传参时 降维为整形指针,传入首元素地址,因此可以用一个整形指针或整形数组接收。由于是整形指针,形参中一维数组的元素个数写不写就无所谓了, 三种写法均正确。
对于 tesst02(),arr2为整形指针数组,每一个元素是整形指针,传入的即为指向整形指针的指针,即 二级指针,因此 两种写法均正确。
4.2二维数组传参
void test(int arr[3][5]) {}; //1 ok?
void test(int arr[][]) {}; //2 ok?
void test(int arr[][5]) {}; //3 ok?
void test(int* arr) {}; //4 ok?
void test(int* arr[5]) {}; //5 ok?
void test(int(*arr)[5]) {}; //6 ok?
void test(int** arr) {}; //7 ok?
int main()
{
int arr[3][5] = { 0 };
test(arr);
}
首先,我们函数可以用二维数组作为参数,由于传参时降维为 指向一维数组的指针,因此我们 不能省略数组的列,否则会导致形参数组指针的 类型不明确,数组指针指向的数组的 元素个数也是数组指针类型的一部分,省略了就无法确定指向多少元素的数组。而由于降维为一维数组指针,行的个数我们就可以省略掉了。 因此1,3是正确的写法;2的写法是错误的。
其次我们来看以指针的形式接收,二维数组传参降维为指向一维数组的指针,所以我们也需用 一维整形数组指针来接收。而4是整形指针,5是指针数组,7是二级指针, 因此只有6是正确的写法。
4.3一级指针传参
当实参是一级指针时,很简单,不要想的太复杂,函数形参就使用 一级指针接收。并没有用一维数组接收的做法。如下:
#include <stdio.h>
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; //arr:首元素地址,整形指针接收
int sz = sizeof(arr) / sizeof(arr[0]);
//一级指针p,传给函数
print(p, sz);
return 0;
}
下面我们可以思考以下,当函数形参是一级指针时,函数可以接收什么参数呢?
Sush as:
void test01(int* p); //test01()能接收什么参数
void test02(char* p); //test02()能接收什么参数
是不是会感觉有点别扭。正常,逆向思维往往是大部分人所欠缺的,下面我们逐一分析。
对于test01(),形参是整形指针,因此毋庸置疑可以 接收一个整形指针;并且由于一维整形数组传参时传入的也是整形指针,因此也可以 接收一维整形数组:
void test(int* p) {};
int main()
{
int n = 10;
int* pn = &n;
int arr[10] = { 10 };
//传入一级整形指针
test(&n);
test(pn);
//传入整形数组
test(arr);
return 0;
}
对于test02(),形参是字符指针,同理,可以 接收字符指针或字符数组。并且,由于C语言中字符串常量的值是其第一个字符的地址,因此test02()还可以 接收一个字符串常量:
void test(char* p) {};
int main()
{
char c = 'b';
char* pc = &c;
char arr[10] = { 'b'};
//传入一级字符指针
test(&c);
test(pc);
//传入字符数组
test(arr);
return 0;
}
4.4二级指针传参
同理,二级指针传参,函数形参用二级指针接收:
void print(int** p) //形参用二级指针
{
printf("num = %d\n", **p);
}
int main()
{
int n = 10;
int* p = &n;
int** pp = &p; //二级指针
print(pp); //二级指针传参
return 0;
}
那么,当函数形参是二级指针,函数又可以接收什么参数呢?
void test01(int** p) //test01()接收什么参数
void test02(char** p) //test02()接收什么参数
对于test01(),形参是二级整形指针,因此函数可以 接收一个二级整形指针,并且由于一级整形指针数组传参时传入的是一级整形指针的地址,即二级整形指针,因此函数也可以 接收一个一级整形指针数组:
void test(int** p) {};
int main()
{
int n = 10;
int* pn = &n;
int** ppn = &pn;
int* arr[10] = { pn };
//传入二级整形指针
test(&pn);
test(ppn);
//传入一级整形指针数组
test(arr);
return 0;
}
对于test02(),形参是二级字符指针,同理可以 接收一个二级字符指针或者一级字符指针数组。然后由于字符串常量的值是首字符的地址,所以一个字符串数组传参时传入的即为二级字符指针,因此还可以 接收一个字符串数组:
void test(char** p) {};
int main()
{
char c = 'b';
char* pc = &c;
char** ppc = &pc;
char* arr[10] = {pc};
char* arr1[10] = { "hello","world" };
//传入二级字符指针
test(&pc);
test(ppc);
//传入一级字符指针数组
test(arr);
//传入字符串数组
test(arr1);
return 0;
}
5. 函数指针⛄
5.1 引入
在C语言中,函数也是有地址的,函数是代码的一部分,程序在运行时,要先将代码加载到内存中以便后续访问,而代码就保存在C程序地址空间中的代码区中。我们来看以下代码:
int main()
{
printf("%p\n", main);
printf("%p\n", &main);
return 0;
}
![](https://i-blog.csdnimg.cn/blog_migrate/0dcf96bc0e700abc14d0b4cd0c245f64.png)
输出的地址即为main函数在代码区的地址。既然是地址,我们能不能将它保存起来呢?这就要谈谈我们的主角了: 函数指针(Function pointer)
5.2 函数指针的使用
int test(int x)
{
return x + 10;
}
int main()
{
int (*p1)(int x) = test;
int (*p2)(int x) = &test;
return 0;
}
其实使用起来很简单,类似于数组指针,*号与p1结合说明p1是一个指针,右边的(int x)代表p1指向函数有一个形参,形参类型为int;左边的int表示函数的返回类型为int。
上述p1和p2其实都是指向test函数的指针,这是因为与数组不同的是, 函数名和&函数名等价,都为函数的地址。因此,我们可以用以下两种方法调用函数:
int test(int x)
{
return x + 10;
}
int main()
{
int (*p1)(int x) = test;
printf("p1: %d\n", (*p1)(10)); //1
printf("p1: %d\n", p1(10)); //2
return 0;
}
通过函数指针来调用函数时, *号其实就是个摆设,有没有都不影响。但是需要注意的是,如果 使用*号需要加上括号,不然p1会先与括号结合,p1就变成一个函数了。
5.3两个有趣的代码
我们来分析一下下面两条语句:
//代码1
(*(void (*)())0)();
//代码2
void (*signal(int , void(*)(int)))(int);
遇到这种代码不要慌, 先抓主体。对于 代码1:主体就是0,然后左边的(void (*)())就是强制类型转化,将0强制类型转化为函数指针,指向的函数无参,返回类型为void。最后对其解引用、调用函数。 因此代码1是一条 函数调用语句。
而对于 代码2: 主体就为signal,signal先于括号结合,因此为一个函数,有两个参数,一个为整形,另一个为函数指针。然后剩下的就为signal的返回值,为函数指针。因此代码2就是 声明一个signal函数 ,函数有两个参数:整形和函数指针,返回值为函数指针。
6. 函数指针数组🌷
6.1引入
我们之前学过了指针数组,其存放的每个元素类型是指针。那当我们把函数的地址保存到数组中,这个数组就叫函数指针数组。写法如下:
int(*pa[10])()
pa先与[10]结合,说明pa是个数组,数组的内容是什么呢?是int(*)()类型的函数指针。
6.2 应用-转移表
假设我们需要实现一个整数计算器,具有加减乘除的功能,我们可能会这样写代码:
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 x, y;
int input = 0;
int ret = 0;
do
{
menu();
printf("请选择:> ");
scanf("%d", &input);
switch (input)
{
case 0:
break;
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;
default:
printf("输入错误,请重新输入\n");
break;
}
} while(input);
return 0;
}
当我们计算器的选项越来越多,switch-case语句也会越来越长,并且我们发现switch-case语句中每个分支我们做的操作都非常相似,显得代码十分冗长。那我们要如何优化这个代码呢?嘿嘿,这就要问问神奇的函数指针数组了:
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 x, y;
int input = 0;
int ret = 0;
int (*pa[5])(int, int) = { NULL,add,sub,mul,div }; //转移表
int sz = sizeof(pa) / sizeof(pa[0]);
do
{
menu();
printf("请选择:> ");
scanf("%d", &input);
if (input > 0 && input < sz)
{
printf("请输入两个操作数:> ");
scanf("%d %d", &x, &y);
ret = pa[input](x, y);
printf("%d\n", ret);
}
else if(input!=0)
{
printf("输入有误,请重新输入\n");
}
} while (input);
return 0;
}
首先,我们将加减乘除四个函数用一个函数指针数组存放起来,其中 NULL作用是占位,使得后续函数的下标与我们的输入对应起来,方便后续代码的编写。
其次,当input为函数指针数组pa的有效下标时,就通过对应下标的函数指针调用函数,这种通过下标来实现跳转到相应函数的函数指针数组我们就称作 转移表。简单来说, 转移表就是一个函数指针数组,数组的内容是自定义函数,我们通过数组下标访问自定义函数。
最后,当我们后续需要添加函数时,我们只需要在转移表(函数指针数组)中添加对应函数即可,十分方便 。
注意❗
由于数组每个元素类型相同,因此转移表中函数指针的类型必须严格一致,即指向的自定义函数参数列表和返回值都要一样,否则转移表就不适用了。
例如:上面将计算器的除法函数返回值改为double,我们就不能单纯的使用一个转移表来编写代码了。
7. 指向函数指针数组的指针🌵
指向函数指针数组的指针是一个指针,指针指向一个数组,数组的每一个元素都是指针,那我们应该如何定义它呢?来看以下代码:
void test(const char* str)
{
printf("%s", str);
}
int main()
{
//定义一个函数指针
void(*pf)(const char*) = test;
//定义一个函数指针数组
void(*arr[5])(const char*);
//给函数指针数组第一个元素赋值
arr[0] = test;
//定义一个指向函数指针数组的指针,并将其指向函数指针数组
void(*(*parr)[5])(const char*) = &arr;
return 0;
}
void(*(*parr)[5])(const char*) = &arr;
我们来看这条语句,首先parr先于*号结合,说明它是一个指针;然后与[]结合,说明它指向了一个数组。然后剩余的部分就是数组的元素类型,是一个函数指针。综上, parr是一个指向函数指针数组的指针变量,存放着arr这个函数指针数组的地址。
🌸以上,就是本期的全部内容啦
🍜像指针这种高档食材,我们当然要细细品味,剩下的部分我们就留到下期不见不散啦^-^
制作不易,能否点个赞再走呢🙏