Hello C语言 —— 进阶指针(二)

极衍

已于 2023-05-21 13:24:01 修改

阅读量97

点赞数 1

分类专栏： C语言学习文章标签： c语言

于 2023-05-21 13:23:20 首次发布

本文链接：https://blog.csdn.net/Cdtu_mid/article/details/130786394

版权

C语言学习专栏收录该内容

13 篇文章 0 订阅

订阅专栏

一、数组参数、指针参数

1、一维数组传参

void test(int arr[])//可以?
{}
void test(int arr[10])//可以?
{}

[ ] 里面可以空着，也可以写数组元素个数，也可以随便写
void test(int *p)//可以?
{}

arr数组名(首元素地址)传递到void test(int*p)
int main()
{
int arr[10] = {0};
test(arr);
}

void test2(int *arr[20])//可以?
{}
void test2(int **p)//可以?
{}

int main()
{

int *arr2[20] = {0};
test2(arr2);
}

因为本身arr2是指针数组，里面放的每个元素的类型都是 *int ，那再用指针来取出它们的时候，就会议以 **p 的样子来传参

就相当于：

int a = 10;

int *p = &a;

int **pp = &p;

2、二维数组传参

void test(int arr[3][5])//可以
{}
void test(int arr[][])//不行
{}
void test(int arr[][5])//可以
{}

int main()
{
int arr[3][5] = {0};
test(arr);
}
总结：二维数组传参，函数形参的设计只能省略第一个 [ ] 的数字。
因为对一个二维数组，可以不知道有多少行，但是必须知道一行多少元素

这样才方便运算

二维数组在怎么用指针来传参呢？

void test(int *arr)不行
{}

//这是一个一级指针，是来接受一个普通变量的，不能来接受二维数组
void test(int* arr[5])不行
{}

//arr先和 [ ] 结合是一个指针数组，而主函数传过来的arr表示的该二维数组的首行地址，地址存放在一个数组中显然不合理
void test(int (*arr)[5])可以
{}

是把二维数组的第一行的地址传给 test() 函数

第一行可以看做一个一维数组，一维数组的地址放到int (*arr）[ 5 ]的数组指针中去

p+1就指向下一行
void test(int **arr)
{}

//这一个二级指针，来接受arr首元素的地址更是扯淡

int main()
{
int arr[3][5] = {0};
test(arr);
}

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;
	int sz = sizeof(arr) / sizeof(arr[0]);
	//一级指针p，传给函数
	print(p, sz);
	return 0;
}

4、二级指针传参

同样，二级指针传参相比于二维数组传参理解起来比较容易，接下里用一段代码来理解吧

#include <stdio.h>
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;
}

二、函数指针

指针进阶1中我们雪亮数组指针，格式是这样子的

int arr[10] = { 0 };
int (*p)[10]=&arr;

那利用类比的思想，不难猜出函数指针的格式

int Add(int x,int y)
{
   return x + y;
}
int main()
{
   int(*pf)(int, int) = Add;//pf就是函数指针变量
   return 0;
}

我们再接着看一段代码

#include <stdio.h>
void test()
{
	printf("hehe\n");
}
int main()
{
	printf("%p\n", test);
	printf("%p\n", &test);
	return 0;
}

打印结果如下

&test 和 test 的地址是一样的，说明对于函数声明来说，&加与不加没什么区别

接下来看两段代码

//代码1
(*(void (*)())0)();
//代码2
void (*signal(int , void(*)(int)))(int);

代码一解析:

//   void (*)() 是函数指针类型
//   void (*p)()
//   给这个函数指针类型加上括号
//   ( void (*)() ) 代表强制转换的意思
//   后面加个0，就是在0的地址上强行加上一个函数
//   ( void (*)() )0
//   最后加上* 解应用
//   ( *( void (*)() ) 0 )();
//   1.首先是把0强制转换为一个函数指针类型，这就意味着0地址处放一个返回类型是void的，无参的函数
//   2.调用0地址处的这个函数

代码二解析：

//   代码2
//   int Add(int,int)
//   函数声明
//
//   void (*signal(int, void(*)(int)))(int);
//   这样看是不是有些复杂，我们可以这样简化
//   typedef void(*pr_t)(int);
//   这样的话就可以简化成这样
//   pr_t signal(int, pr_t);
//   signal是一个函数声明
//   signal 函数的参数第一个是 int 类型第二个是 void(*)(int) 函数指针类型
//   signal 的返回类型也是 void(*)(int)

三、函数指针数组

学过指针数组，那函数指针数组就不难理解了，直接上代码：

#include<stdio.h>
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(*p1)(int, int) = Add;
	int(*p2)(int, int) = Sub;
	int(*p3)(int, int) = Mul;
	int(*p4)(int, int) = Div;

	//函数指针数组
	int(*p[4])(int, int) = { Add,Sub,Mul,Div };
	int i = 0;
	for (i = 0;i < 4;i++)
	{
		int ret = p[i](4, 8);
		printf("%d\n", ret);
	}

	return 0;
}

work hard!!