首页 > 其他分享 >指针万字超级最强i解析与总结!!!!!

指针万字超级最强i解析与总结!!!!!

时间:2024-11-09 14:15:32浏览次数:5  
标签:万字 arr return int 数组 printf 解析 指针

文章目录

1.内存和地址

1.1内存

我们知道计算机上CPU(中央处理器)在处理数据的时候,需要的数据是在内存中读取的,处理后的数据也会放回内存中,那我们买电脑的时候,电脑上内存是8GB/16GB/32GB等,那这些内存空间如何⾼效的管理呢?
其实也是把内存划分为⼀个个的内存单元,每个内存单元的⼤⼩取1个字节
⼀个⽐特位可以存储⼀个2进制的位1或者0

1byte = 8bit
1KB = 1024byte
1MB = 1024KB
1GB = 1024MB
1TB = 1024GB
1PB = 1024TB

在这里插入图片描述

1.2究竟该如何理解编址

CPU访问内存中的某个字节空间,必须知道这个字节空间在内存的什么位置,⽽因为内存中字节很多,所以需要给内存进⾏编址

计算机中的编址,并不是把每个字节的地址记录下来,⽽是通过硬件设计完成的

⾸先,必须理解,计算机内是有很多的硬件单元,⽽硬件单元是要互相协同⼯作的。所谓的协
同,⾄少相互之间要能够进⾏数据传递。但是硬件与硬件之间是互相独⽴的,那么如何通
信呢?答案很简单,⽤"线"连起来。⽽CPU和内存之间也是有⼤量的数据交互的,所
以,两者必须也⽤线连起来。

我们今天关⼼⼀组线,叫做地址总线

32位机器有32根地址总线,每根线只有两态,表⽰0,1【电脉冲有⽆】,那么⼀根线,就能表⽰2种含义,2根线就能表⽰4种含义,依次类推。32根地址线,就能表⽰2^32种含义,每⼀种含义都代表⼀个地址。

地址信息被下达给内存,在内存上,就可以找到该地址对应的数据,将数据在通过数据总线传⼊CPU内寄存器
在这里插入图片描述

2.指针变量和地址

2.1 取地址操作符(&)

在C语⾔中创建变量其实就是向内存申请空间
在这里插入图片描述
上述的代码就是创建了整型变量a,内存中申请4个字节,⽤于存放整数10,其中每个字节都
有地址,上图中4个字节的地址分别是

0x006FFD70
0x006FFD71
0x006FFD72
0x006FFD73

在这里插入图片描述

2.2指针变量和解引用操作符(*)

2.2.1指针变量

那我们通过取地址操作符(&)拿到的地址是⼀个数值,⽐如:0x006FFD70,这个数值有时候也是需要存储起来,⽅便后期再使⽤的,那我们把这样的地址值存放在哪⾥呢?答案是:指针变量中

int* pa = &a;
//取出a的地址并存储到指针变量pa中

指针变量也是⼀种变量,这种变量就是⽤来存放地址的,存放在指针变量中的值都会理解为地址

2.2.2如何拆解指针类型

在这里插入图片描述

2.2.3解引用操作符

在现实⽣活中,我们使⽤地址要找到⼀个房间,在房间⾥可以拿去或者存放物品。
C语⾔中其实也是⼀样的,我们只要拿到了地址(指针),就可以通过地址(指针)找到地址(指针)指向的对象,这⾥必须学习⼀个操作符叫解引⽤操作符(*)

 int a = 100;
 int* pa = &a;
 *pa = 0;

*pa的意思就是通过pa中存放的地址,找到指向的空间,*pa其实就是a变量了;所以 *pa=0,这个操作符是把a改成了0

2.3 指针变量的大小

前⾯的内容我们了解到,32位机器假设有32根地址总线,每根地址线出来的电信号转换成数字信号后
是1或者0,那我们把32根地址线产⽣的2进制序列当做⼀个地址,那么⼀个地址就是32个bit位,需要4个字节才能存储

同理64位机器,假设有64根地址线,⼀个地址就是64个⼆进制位组成的⼆进制序列,存储起来就需要
8个字节的空间,指针变量的⼤⼩就是8个字节

3.指针变量类型的意义

3.1指针的解引用

在这里插入图片描述

3.2指针±整数

#include <stdio.h>
int main()
{
int n = 10;
char *pc = (char*)&n;
int *pi = &n;
printf("%p\n", &n);
printf("%p\n", pc);
printf("%p\n", pc+1);
printf("%p\n", pi);
printf("%p\n", pi+1);
return  0;
}

在这里插入图片描述

char* 类型的指针变量+1跳过1个字节,这就是指针变量的类型差异带来的变化。
int* 类型的指针变量+1跳过了4个字节
结论:指针的类型决定了指针向前或者向后⾛⼀步有多⼤(距离)

3.3 void* 指针

在指针类型中有⼀种特殊的类型是void* 类型的,可以理解为⽆具体类型的指针(或者叫泛型指
针),这种类型的指针可以⽤来接受任意类型地址。但是也有局限性,void* 类型的指针不能直接进⾏指针的±整数和解引⽤的运算。

 #include <stdio.h>
 int main()
 {
 int a = 10;
 void* pa = &a;
 void* pc = &a;
 *pa = 10;
 *pc = 0;
 return 0;
 }

在这里插入图片描述
那么void* 类型的指针到底有什么⽤呢?⼀般void* 类型的指针是使用在函数参数的部分,⽤来接收同类型数据的地址,这样的设计可以实现泛型编程的效果,使得⼀个函数来处理多种类型的数据

4.指针运算

4.1指针±整数

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

4.2指针-指针

1.指针-指针时,两个指针指向同一块区域
2.指针-指针的绝对值,是两个指针之间的元素个数

#include  <stdio.h>
int main()
{   
  int arr[6] = { 1,2,3,4,5,6 };
  int c = arr[5] - arr[0];
  printf("%d", c);//5
  return 0;
}

库函数strlen实现

#include <stdio.h>
size_t mystrlen(char* str)
{
	size_t* p = str;
	while (*str != '\0')
		str++;
	return str - p;
}
int main()
{   
	char arr[] = "abcdefj";
	size_t len = mystrlen(arr);
	printf("%zd", len);//7
	return 0;
}

4.3 指针的关系运算

两个地址可以比较大小
在这里插入图片描述

数组随着下标增长地址从低到高变化,

#include <stdio.h>
int main()
{   
	int arr[] = { 1,2,3,4,5 };
	int* p = arr;
	int sz = sizeof(arr) / sizeof(arr[0]);
	while (p < &arr[sz])
	{
		printf("%d ", *p);
			p++;
	}
	return 0;
}

5.const修饰指针

5.1 const修饰指针

变量是可以修改的,如果把变量的地址交给⼀个指针变量,通过指针变量的地址的改变也可以修改这个变量。
但是如果我们希望⼀个变量加上⼀些限制,不能被修改,怎么做呢?这就是const的作⽤

 #include <stdio.h>
 int main()
 {
 int m = 0;
 m = 20;//m
是可以修改的
const int n = 0;
 n = 20;//n
是不能被修改的
return 0;
 }

但是如果我们绕过n,使⽤n的地址,去修改n就能做到了,虽然这样做是在打破语法规则

 #include <stdio.h>
int main()
{
const int n = 0;
printf("n = %d\n", n);//0
int*p = &n;
*p = 20;
printf("n = %d\n", n);//20
return 0;
}

我们可以看到这⾥⼀个确实修改了,但是我们还是要思考⼀下,为什么n要被const修饰呢?就是为了
不能被修改,如果p拿到n的地址就能修改n,这样就打破了const的限制,这是不合理的,所以应该让
p拿到n的地址也不能修改n,那接下来怎么做呢

5.2 const 修饰指针变量

#include <stdio.h>
int main()
{   
	int num = 10;
	int m = 30;
	const int* p = &num;
	//num不能再改变了
	p = &m;
	printf("%d\n", *p);//30
	return 0;
}

const如果放在*的左边,修饰的是指针指向的内容,保证指针指向的内容不能通过指针来改变
但是指针变量本⾝的内容可变。
const如果放在*的右边,修饰的是指针变量本⾝,保证了指针变量的内容不能修改,但是指针指
向的内容,可以通过指针改变

6.野指针

概念:野指针就是指针指向的位置是不可知的(随机的、不正确的、没有明确限制的)
理解野指针的时候,你可以把野指针想成“野狗”,是没有主⼈的,是危险的

6.1野指针成因

6.1.1指针未初始化

p没有指向空间

#include <stdio.h>
 int main()
 {        
int *p;//
局部变量指针未初始化,默认为随机值
*p = 20;
 return 0;
 }

6.1.2 指针的越界访问

#include <stdio.h>
int main()
{   
	int arr[10] = { 0 };
	int* p = arr;
	for (int i = 0;i < 11;i++)
	{
		*(p++) = 1;
	}
	return 0;
}

当指针指向的范围超过数组arr时,p就是野指针

6.1.3指针指向的空间释放

在这里插入图片描述
p得到地址的一瞬间就是野指针了

6.2如何规避野指针

6.2.1指针初始化

如果明确知道指针指向哪⾥就直接赋值地址,如果不知道指针应该指向哪,可以给指针赋值NULL.
NULL 是C语⾔中定义的⼀个标识符常量,值是0,0也是地址,这个地址是⽆法使⽤的,读写该地址
会报错

 #include <stdio.h>
 int main()
 {
 int num = 10;
 int*p1 = &num;
 int* p2 = NULL;
 return 0;
 }

6.2.2小心指针越界

⼀个程序向内存申请了哪些空间,通过指针也就只能访问哪些空间,不能超出范围访问,超出了就是
越界访问。
使⽤指针的时候⼀定要注意边界,通过指针访问的内存是不能越界的
例子如 2.1.2

6.2.3指针变量不再使用时,及时置NULL,指针使用之前检查有效性

当指针变量指向⼀块区域的时候,我们可以通过指针访问该区域,后期不再使⽤这个指针访问空间的时候,我们可以把该指针置为NULL。因为约定俗成的⼀个规则就是:只要是NULL指针就不去访问,
同时使⽤指针之前可以判断指针是否为NULL

#include <stdio.h>
int main()
{
  int arr[10] = {1,2,3,4,5,6,7,8,9,10};
  int *p = &arr[0];
 for(i=0; i<10; i++)
 {
 *(p++) = i;
 }
 //
此时p已经越界了,可以把p置为NULL
 p = NULL;
 //
下次使⽤的时候,判断p不为NULL的时候再使⽤
//...
 p = &arr[0];//
重新让p获得地址
if(p != NULL) //判断
{
 //...
 }
 return 0;
 }

6.2.4避免返回局部变量的地址

如2.1.3 不要返回局部变量的地址。

7.assert断言

assert.h 头⽂件定义了宏assert() ,⽤于在运⾏时确保程序符合指定条件,如果不符合,就报错终⽌运⾏。这个宏常常被称为“断⾔”

assert(p != NULL);
//验证p是否等于NULL,如果不等于就继续运行,否则停止运行并给出报错信息

assert() 宏接受⼀个表达式作为参数。

  • 如果该表达式为真(返回值⾮零) assert()不会产⽣任何作⽤,程序继续运⾏

  • 如果该表达式为假(返回值为零),assert() 就会报错,在标准错误流stderr 中写⼊⼀条错误信息,显⽰没有通过的表达式,以及包含这个表达式的⽂件名和⾏号
    在这里插入图片描述

8.指针的使用和传址调用

8.1 strlen的模拟实现

#include <stdio.h>
#include <assert.h>
size_t my_strlen(const char* str)
{
	size_t count = 0;
	assert(str != NULL);
	while (*str != '\0')
	{
		count++;
		str++;
	}
	return count;
}
int main()
{
	char arr[] = "abcdef";
	size_t len = my_strlen(arr);
	printf("%zd", len);
	return 0;
}

8.2传值调用和传址调用

在函数调⽤的时候有传值调⽤,也有传址调⽤,那这两种调⽤⽅式有什么区别呢?
传址调⽤,就得使⽤指针;学习指针的⽬的是使⽤指针解决问题,那什么问题,⾮指针不可呢?

例如:写⼀个函数,交换两个整型变量的值
⼀番思考后,我们可能写出这样的代码

 #include <stdio.h>
 void Swap1(int x, int y)
 {
 int tmp = x;
 x = y;
 y = tmp;
 }
 int main()
 {
 int a = 0;
 int b = 0;
 scanf("%d %d", &a, &b);
 Swap1(a, b);
 printf("
交换前:
a=%d b=%d\n", a, b);
 printf("
交换后:
a=%d b=%d\n", a, b);
 return 0;
 }

在这里插入图片描述
在这里插入图片描述
结论:实参传递给形参的时候,形参会单独创建⼀份临时空间来接收实参,对形参的修改不影响实

所以Swap是失败的了

那怎么办呢?
我们现在要解决的就是当调⽤Swap函数的时候,Swap函数内部操作的就是main函数中的a和b,直接
将a和b的值交换了。那么就可以使⽤指针了,在main函数中将a和b的地址传递给Swap函数,Swap
函数⾥边通过地址间接的操作main函数中的a和b,并达到交换的效果就好了

#include <stdio.h>
void swap(int* a1, int* b1)
{
	int t = *a1;
	*a1 = *b1;
	*b1 = t;
}
int main()
{   
	int a = 10;
	int b = 0;
	swap(&a, &b);
	printf("%d %d", a, b);
	return 0;
}

这⾥调⽤swap函数的时候是将变量的地址传递给了函数,这种函数调⽤⽅式叫:传址调⽤

传址调⽤,可以让函数和主调函数之间建⽴真正的联系,在函数内部可以修改主调函数中的变量;所以未来函数中只是需要主调函数中的变量值来实现计算,就可以采⽤传值调⽤。如果函数内部要修改主调函数中的变量的值,就需要传址调⽤

9.数组名的理解

数组名是⾸元素的地址

 #include <stdio.h>
 int main()
 {
 int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };
 printf("&arr[0] = %p\n", &arr[0]);
 printf("arr     = %p\n", arr);
return 0;
 }
 

在这里插入图片描述

数组名如果是数组⾸元素的地址,那下⾯的代码怎么理解呢?

#include <stdio.h>
int main()
 {
 int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };
 printf("%d\n", sizeof(arr));
 return 0;
 }

输出的结果是:40,如果arr是数组⾸元素的地址,那输出应该的应该是4/8才对

在这里插入图片描述

#include <stdio.h>
int main()
{
int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };
printf("&arr[0]   = %p\n", &arr[0]);
printf("&arr[0]+1 = %p\n", &arr[0]+1);
printf("arr       = %p\n", arr);
printf("arr+1      = %p\n", arr+1);
printf("&arr       = %p\n", &arr);
printf("&arr+1     = %p\n", &arr+1);
return 0;
}

&arr[0] = 0077F820
&arr[0]+1 = 0077F824
arr = 0077F820
arr+1 = 0077F824
&arr = 0077F820
&arr+1 = 0077F848

这⾥我们发现&arr[0]和&arr[0]+1相差4个字节,arr和arr+1相差4个字节,是因为&arr[0]和arr都是
⾸元素的地址,+1就是跳过⼀个元素。但是&arr和&arr+1相差40个字节,这就是因为&arr是数组的地址,+1操作是跳过整个数组的
到这⾥⼤家应该搞清楚数组名的意义了吧。
数组名是数组⾸元素的地址,但是有2个例外

10.使用指针访问数组

有了前⾯知识的⽀持,再结合数组的特点,我们就可以很⽅便的使⽤指针访问数组了

#include <stdio.h>
int main()
{   
	int arr[] = { 1,2,3,4,5 };
	int sz = sizeof(arr) / sizeof(arr[0]);
	int* p = arr;
	for (int i = 0;i < sz;i++)
	{
		scanf("%d", p);
		p++;
	}
	p = arr;//重置p的位置
	for (int i = 0;i < sz;i++)
	{
		printf("%d ", p[i]);
	}
	return 0;
}

p++操作,让指针挪远之后,记得重置p的位置


#include <stdio.h>
int main()
{   
	int arr[10] = { 0 };
	int* p = arr;
	int sz=sizeof(arr)/sizeof(arr[0]);
	for (int i = 0;i < sz;i++)
	{
		scanf("%d", p + i);
		//scanf("%d",arr+i);
	}
	for (int i = 0;i < sz;i++)
	{
		printf("%d ", *(p + i));
	}

	return 0;
}

将*(p+i)换成p[i]也是能够正常打印的,所以本质上p[i]是等价于*(p+i)
同理arr[i] 应该等价于*(arr+i),数组元素的访问在编译器处理的时候,也是转换成⾸元素的地址+偏移
量求出元素的地址,然后解引⽤来访问的

11.一维数组传参的本质

当我们已经有了⼀维数组,我们对⼀维数组的处理是否可以使⽤函数呢?这样就涉及到将⼀维数组传
递给函数,就是⼀维数组传参。
⽐如:我们现在想写⼀个函数打印⼀个整型数组的内容。

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

我们前⾯是在函数外部计算数组的元素个数,那我们可以把函数传给⼀个函数后,函数内部求数组的元素个数吗

#include <stdio.h>
void test(int arr[], int sz)
{
	printf("%d", sizeof(arr) / sizeof(arr[0]));
}
int main()
{   
	int arr[] = { 1,2,3,4,5,6,7,8,9,10 };
	int sz = sizeof(arr) / sizeof(arr[0]);
	printf("%d\n", sz);
	test(arr, sz);
	return 0; 
}

在这里插入图片描述

我们发现在函数内部是没有正确获得数组的元素个数

这就要学习数组传参的本质了,上个⼩节我们学习了:数组名是数组⾸元素的地址
那么在数组传参的时候,传递的是数组名,也就是说本质上数组传参本质上传递的是数组⾸元素的地址
所以函数形参的部分理论上应该使⽤指针变量来接收⾸元素的地址

那么在函数内部我们写sizeof(arr) 计算的是⼀个地址的⼤⼩(单位字节)⽽不是数组的⼤⼩(单
位字节)。正是因为函数的参数部分是本质是指针,所以在函数内部是没办法求的数组元素个数的。


#include <stdio.h>
void test1(int arr[], int sz)//参数写成数组形式,本质上还是指针

{
	printf("%d\n", sizeof(arr));
}
void test2(int* p, int sz)//参数写成指针形式

{
	printf("%d", sizeof(p)); //计算⼀个指针变量的⼤⼩

}
int main()
{   
	int arr[] = { 1,2,3,4,5,6,7,8,9,10 };
	int sz = sizeof(arr) / sizeof(arr[0]);
	test1(arr, sz);
	test(arr, sz);
	return 0; 
}

总结:⼀维数组传参,形参的部分可以写成数组的形式,也可以写成指针的形式。

12.冒泡排序

#include <stdio.h>
void test1(int*arr,int sz)
{
	for (int i = 0;i < sz - 1;i++)
	{
		for (int j = 0;j < sz - 1 - i;j++)
		{
			if (arr[j] > arr[j + 1])
			{
				int t = arr[j];
				arr[j] = arr[j + 1];
				arr[j + 1] = t;
			}
		}
	}
}
int main()
{   
	int arr[] = { 9,8,7,5,4,6,3,2,10,1 };
	int sz = sizeof(arr) / sizeof(arr[0]);
	test1(arr, sz);
	for (int i = 0;i < sz ;i++)
	{
		printf("%d ", arr[i]);
	}
	return 0;
}

优化

#include <stdio.h>
void test2(int*arr,int sz)
{
	for (int i = 0;i < sz - 1;i++)
	{   
		int flag = 1;
		for (int j = 0;j < sz - 1 - i;j++)
		{   
			if (arr[j] > arr[j + 1])
			{   
				int t = arr[j];
				arr[j] = arr[j + 1];
				arr[j + 1] = t;
				flag = 0;
			}
		}
		if (flag == 1)
			break;
	}
}
int main()
{   
	int arr[] = { 9,8,7,5,4,6,3,2,10,1 };
	int sz = sizeof(arr) / sizeof(arr[0]);
	test2(arr, sz);
	for (int i = 0;i < sz ;i++)
	{
		printf("%d ", arr[i]);
	}
	return 0;
}

13.二级指针

在这里插入图片描述

在这里插入图片描述


#include <stdio.h>
int main()
{
	int a = 10;
	int b = 20;
	int* pa=&a;
	int const * * ppa=&pa;
	*ppa = &b;//等价pa=&b
	printf("%d", **ppa);//20
	
}

*pa解开是整形,*ppa解开是pa指针,**ppa解开也是整形 **ppa可看作*(*ppa)

#include <stdio.h>
int main()
{
	int a = 10;
	int b = 20;
	int* pa=&a;
	int ** ppa=&pa;
	**ppa = 30;//等价于*pa=30;//等价pa=30;
	printf("%d", **ppa);//30
	printf(
}
#include <stdio.h>
int main()
{
	int a = 10;
	int b = 20;
	int* pa=&a;
	int* pb = &b;
	int * const *  ppa=&pa;
	ppa = &pb;
	printf("%d", **ppa);
}

可以使二级指针指向另外一个一级指针
哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈终于搞懂了

14.指针数组

指针数组是指针还是数组?
我们类⽐⼀下,整型数组,是存放整型的数组,字符数组是存放字符的数组。
那指针数组呢?是存放指针的数组。
在这里插入图片描述

在这里插入图片描述

15.指针数组模拟二维数组

#include <stdio.h>
int main()
{   
	int arr1[] = { 1,2,3,4,5 };
	int arr2[] = { 2,3,4,5,6 };
	int arr3[] = { 3,4,5,6,7 };
	int* parr[] = {arr1,arr2,arr3};
	for (int i = 0;i < 3;i++)
	{
		for (int j = 0;j < 3;j++)
		{
			printf("%d ", parr[i][j]);
		}
		printf("\n");
	}

	return 0; 
}

在这里插入图片描述

arr[i]==*(arr+i)
arr[i][j]==x[j]==*(x+j)
==*(*(arr+1)+j)

在这里插入图片描述
在这里插入图片描述

16.字符指针变量

在这里插入图片描述

将字符串abcdef首元素a的地址给了p
字符数组可以放字符串,且字符数组可以修改如

arr[10]=“wasdrrr”;

const char*p=“abcedf”;

常量字符串和数组非常相似,也在一个连续空间存放了多个字符,但常量的内容不能修改,即*p='a’就错误,所以加了const
在这里插入图片描述

在这里插入图片描述
指针数组可以存字符串

17.数组指针变量

17.1数组指针变量是什么?

在这里插入图片描述

17.2数组指针变量怎么初始化

数组指针变量是⽤来存放数组地址的,那怎么获得数组的地址呢?就是我们之前学习的==&数组名==

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

在这里插入图片描述

18.二维数组传参的本质

过去我们有⼀个⼆维数组的需要传参给⼀个函数的时候,⽐如有⼀个整型的⼆维数组,写⼀个函数
test,打印数组的全部内容。我们可以这样写:

#include <stdio.h>
void test(int arr[3][5], int x, int y)
{
	for (int i = 0;i < 3;i++)
	{
		for (int j = 0;j < 5;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} };
	test(arr, 3, 5);
	return 0;
}

在这里插入图片描述

#include <stdio.h>
void test(int (*pa)[5], int x, int y)
{
	for (int i = 0;i < 3;i++)
	{
		for (int j = 0;j < 5;j++)
		{
			printf("%d ", pa[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;
}

总结:⼆维数组传参,形参的部分可以写成数组,也可以写成指针形式

19.函数指针变量

在这里插入图片描述

其实函数也是有地址的,我们做个测试:
在这里插入图片描述

19.1函数指针变量的创建

函数指针变量应该是⽤来存放函数地址的,未来通过地址能够调⽤函数的。
如果我们要将函数的地址存放起来,就得创建函数指针变量咯,函数指针变量的写法其实和数组指针
⾮常类似。如下

#include <stdio.h>
void Add(int x,int y)
{
	return x + y;
}
int main()
{   
	int (*p1)(int,int ) = Add;
	int (*p2)(int x, int y) = &Add;//x,y可不写
	return 0;
}

在这里插入图片描述

19.2函数指针变量的使用

#include <stdio.h>
void Add(int x,int y)
{
	return x + y;
}
int main()
{   
	int (*p1)(int,int ) = Add;
	printf("%d", p1(3, 5));//(*p1)
	return 0;
}

19.3两段有趣的代码

在这里插入图片描述

在这里插入图片描述
在这里插入图片描述

19.3.1 typedef 关键字

在这里插入图片描述
在这里插入图片描述

typedef void((*p_fun)(int));
//typedef int(*p_arr)[5];
p_fun signal(int, p_fun);

20.函数指针数组

#include <stdio.h>
int Add(int x,int y)
{
	return x + y;
}
int Sub(int x, int y)
{
	return x - y;
}
int main()
{
	int(*parr[])(int ,int) = {Add,Sub};
	printf("%d", parr[0](3, 1));
}

21.转移表

#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 (*parr[])(int, int) = { NULL,Add,Sub,Div,Mul };
	int input;
	
	
	do
	{   
		int x, y;
		printf("******1.Add      2.Sub*******\n");
		printf("******3.Div      4.Mul*******\n");
		printf("*********0.退出游戏**********\n");
		scanf("%d", &input);
		if (0 == input)
		{
			printf("退出游戏");
			break;
		}
		scanf("%d %d", &x, &y);
		int c=parr[input](x, y);
		printf("%d", c);
	} while (input);
	 return 0;
}

这个函数数组称作转移表

22.回调函数是什么?

回调函数就是⼀个通过函数指针调⽤的函数
如果你把函数的指针(地址)作为参数传递给另⼀个函数,当这个指针被⽤来调⽤其所指向的函数
时,被调⽤的函数就是回调函数。回调函数不是由该函数的实现⽅直接调⽤,⽽是在特定的事件或条
件发⽣时由另外的⼀⽅调⽤的,⽤于对该事件或条件进⾏响应

#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;
}
void cac(int (*pf)(int ,int) )//用所指向函数形式接收
{   
	int m, n;
	scanf("%d %d", &m, &n);
	int c=pf(m,n);
	printf("%d\n", c);
}
int main()
{
	int input;
	do {
		printf("****1.加法****\n");
		printf("****2.减法****\n");
		printf("****3.乘法****\n");
		printf("****4.除法****\n");
		printf("****0.退出****\n");
		scanf("%d", &input);
		switch (input)
		{
		case 1:
			cac(Add);
			break;
		case 2:
			cac(Sub);
			break;
		case 3:
			cac(Mul);
			break;
		case 4:
			cac(Div);
			break;
		case 0:
			break;
		default:
			printf("输入错误,请重新输入");
			break;
		}
	} while (input);
	
	return 0;
}

23.qsort使用举例

23.1使用qsort函数排序整形数据

#include <stdio.h>
int paixu(const void* e1, const void* e2)
{
	return *(int*)e1 - *(int*)e2;
}
int main()
{   
	int arr[] = { 1,2,5,4,5,7,8,9,6,3 };
	qsort(arr, sizeof(arr) / sizeof(arr[0]), sizeof(arr[0]), paixu);
	int i = 0;
	for (i = 0;i < sizeof(arr)/sizeof(arr[0]);i++)
	{
		printf("%d ", arr[i]);
	}
	return 0;
}

23.2使用sqort排序结构数据

在这里插入图片描述

#include <stdio.h>
#include <stdlib.h>
struct stu
{
	char name[20];
	int age;
};
int pum1(const void* e1, const void* e2)
{
	return strcmp(((struct stu*)e1)->name, ((struct stu*)e2)->name);
}
int main()
{   
	
	struct stu arr[3] = { {"zhangsan",15},{"lisi",19},{"wangwu",20} };
	qsort(arr, sizeof(arr) / sizeof(arr[0]), sizeof(arr[0]), pum1);
	
}

strcpm比较俩字符串大小,对应位置字符的ASCLL值。
按照年龄来排序,想从大到小排只需改变return两边的位置

#include <stdio.h>
#include <stdlib.h>
struct stu
{
	char name[20];
	int age;
};

int pum2(const void* e1, const void* e2)
{
	return (*(struct stu*)e1).age - (*(struct stu*)e2).age;
}
int main()
{   
	
	struct stu arr[3] = { {"zhangsan",15},{"lisi",30},{"wangwu",20} };
	qsort(arr, sizeof(arr) / sizeof(arr[0]), sizeof(arr[0]), pum2);
	
}

24.qsort函数的模拟实现

#include <stdio.h>
void parr(const void*e1,const void*e2)
{
	return *(int*)e1 - *(int*)e2;
}
void swap( char* t1, char* t2,size_t width)
{
	int tmp=0;
	for (int i = 0;i < width;i++)
	{
		tmp = *t1;
		*t1 = *t2;
		*t2 = tmp;
		t1++;
		t2++;
	}

}
void bubble(void* base, size_t sz,size_t width, int (*pa)(const void* e1,const void* e2))
{
	int i = 0;
	for (i = 0;i < sz-1;i++)
	{
		for(int j=0;j<sz-1-i;j++)
		{
			if ((pa((char*)base + j * width, (char*)base + (j + 1) * width))>0)
			{
				swap((char*)base +j*width,(char*)base +(j+1)*width,width);
			}
		}
	}
}
int main()
{   
	int arr[] = { 1,9,8,5,4,6,7,2,3,0 };
	bubble (arr, sizeof(arr) / sizeof(arr[0]), sizeof(arr[0]), parr);
	for (int i = 0;i < sizeof(arr) / sizeof(arr[0]);i++)
	{
		printf("%d ", arr[i]);
	}
	return 0;
}

在这里插入图片描述

标签:万字,arr,return,int,数组,printf,解析,指针
From: https://blog.csdn.net/2403_87165176/article/details/143609252

相关文章

  • 视频分享——多款AI游戏外挂原理,深度解析,战斗力爆表!
    相关视频地址:多款AI游戏外挂原理,深度解析,战斗力爆表!强化学习算法library库:(集成库)https://github.com/Denys88/rl_gameshttps://github.com/Domattee/gymTouch个人github博客地址:https://devilmaycry812839668.github.io/......
  • 二维数组和数组指针数组的关系
    在深入理解指针end中,我在最后写了一长段代码#include<stdio.h>voidtest1(intarr[][5],intx,inty)//voidtest1(int(*p)[5],intx,inty){ for(inti=0;i<x;i++) { for(intj=0;j<y;j++) { //printf("%d",*(*(p+i)+j)); print......
  • 汽车共享管理:SpringBoot技术深度解析
    3系统分析3.1可行性分析通过对本共享汽车管理系统实行的目的初步调查和分析,提出可行性方案并对其一一进行论证。我们在这里主要从技术可行性、经济可行性、操作可行性等方面进行分析。3.1.1技术可行性本共享汽车管理系统采用SSM框架,JAVA作为开发语言,是基于WEB平台的B/S......
  • 8章13节:网络图(知识图谱)绘制的深度解析(更新20241109)
    网络图是一种广泛应用于数据分析的可视化工具,能够有效展示事物之间的关系。在医药行业,网络图被用来分析复杂的关系,例如药物与疾病之间的关联、患者与医疗服务的互动等。通过网络图,研究人员和决策者能够直观地理解数据中的结构模式,发现潜在的规律和趋势,进而做出更为精准的判断......
  • HarmonyOS Next中密码类数据保护场景解析
    本文旨在深入探讨华为鸿蒙HarmonyOSNext系统(截止目前API12)在开发多语言电商平台方面的技术细节,基于实际开发实践进行总结。主要作为技术分享与交流载体,难免错漏,欢迎各位同仁提出宝贵意见和问题,以便共同进步。本文为原创内容,任何形式的转载必须注明出处及原作者。在当今数字化......
  • HarmonyOS Next之Asset Store Kit基础功能全解析
    本文旨在深入探讨华为鸿蒙HarmonyOSNext系统(截止目前API12)在开发多语言电商平台方面的技术细节,基于实际开发实践进行总结。主要作为技术分享与交流载体,难免错漏,欢迎各位同仁提出宝贵意见和问题,以便共同进步。本文为原创内容,任何形式的转载必须注明出处及原作者。在HarmonyOS......
  • 《破阵子 - 黄河》——雷家林诗歌解析
    昆仑高处冰河,直下黄流错落。两岸荒原万古色,五千风雨任洗磨。炎黄厚德长流,青史不尽同歌。夕阳西下看壶口,万马奔腾可奈何。心潮逐浪多。(破阵子--黄河)黄河在《破阵子》中的象征意义黄河的自然景观与历史地位黄河,作为中国第二长河,其发源地昆仑山脉赋予了它独特的地理特征。在......
  • 直播短视频系统,Mysql执行顺序代码解析
    直播短视频系统,Mysql执行顺序代码解析MySQL执行顺序FROM<left_table>ON<join_condition><join_type>JOIN<right_table>WHERE<where_condition>GROUPBY<group_by_list>HAVING<having_condition>SELECTDISTINCT<select_list&......
  • 【数据结构】快慢指针探秘:理解链表与数组中的环结构
    在处理链表或数组时,我们经常需要在一次遍历中找到特定的位置或检测某种模式。这时,快慢指针技术就能成为强大的工具,尤其在链表面试题中。本文将详细介绍什么是快慢指针、它们的工作原理,并通过一些实际应用帮助你理解这种技巧。学完后,你将掌握这种技巧的核心以及如何在代码中......
  • 【华为OD技术面试手撕真题】82、环形链表II | 手撕真题+思路参考+代码解析(C & C++ & J
    文章目录一、题目......