C语言数组和指针

快来打我* 2024-04-06 12:16 56阅读 0赞

#### 文章目录 ####

*  数组
 *   *  一维数组
     *  二维数组
     *  数组名是数组首元素的地址
 *  指针
 *   *  指针类型的意义
     *  野指针
     *   *   *  1.非法访问
             *  2.越界访问，数组越界
             *  3.局部变量销毁
     *  如何规律避免野指针
     *   *   *  1.指针进行初始化
             *  2.小心指针越界
             *  3.指针指向的空间及时释放 ，既是值为NULL。
             *  4.指针使用之前检查有效性
     *  指针减指针
     *  指针的关系运算
     *  数组和指针
     *  二级指针
 *  指针数组
 *  数组指针
 *  函数指针
 *  函数指针数组
 *   *   *  小结
 *  回调函数
 *  用上面的方法写一个计算器
 *   *  计算机基本函数
     *   *  用函数指针数组编写计算器
         *  回调函数编写计算器
 *  欣赏两端有趣的代码

## 数组 ##

### 一维数组 ###

int arr[10]={
        0};
    
    只初始第一个位置为0，剩下默认为0

![一维数组][6be52d2d452c48beb7aa4016b39fe500.png_pic_center]

\[\]为下标引用操作符。

数组名是数组首元素的地址。

一维数组在内存中连续存放。

随着下标的增长，地址是由低到高持续增长的。

### 二维数组 ###

int arr[3][4]={
        1,2,3,4,5,6,7,8,9,10,11,12};
    
    其中第一个[]操作符表示行，第二个操作符[]表示列。
    
    int arr[3][4]={
        {
        1,2,3,4},{
        5,6,7,8},{
        9,10,11,12}};
    
    int arr[][4]={
        {
        1,2,3,4},{
        5,6,7,8},{
        9,10,11,12}};

![二维数组][2f6ae192c7454486bcbaf24861a71e1e.png_pic_center]

在二维数组中，行可以省略，列不可以省略。  
![在这里插入图片描述][9b293361a84b4e29b808e2a8f0a1b5f5.jpeg_pic_center]

### 数组名是数组首元素的地址 ###

但有两个例外

1.sizeof(数组名)，在这里的数组名表示整个数组，计算的是整个数组的大小单位是字节。

2.&数组名，数组名表示整个数组，取出的是整个数组的地址。

## 指针 ##

&a
    
    拿到的是a的4个字节中第一个字节的地址

### 指针类型的意义 ###

1.指针类型决定了，指针解引用的权限有多大。

2.指针类型决定了，指针走一步能走多远（步长）。

### 野指针 ###

##### 1.非法访问 #####

int main()
    {
        
    	int *p;
    //p是一个局部的指针变量，局部变量不初始化的话，默认是随机值。
    	*p=20;
    //非法访问内存
    	return 0;
    }

##### 2.越界访问，数组越界 #####

int main()
    {
        
    	int arr[10]={
        0};
    	int* p=arr;
    	int i=0;
    	for(i=0;i<12;i++)
    	{
        
    		printf("%d",*(p+i));
    	}
    //数组只占了10个位置，
    //但访问的时候一直访问到了第12个位置
    //导致了数组越界访问
    	return 0;
    }

##### 3.局部变量销毁 #####

int *test()
    {
        
    	int a=10;
    	return &a;
    }
    //这里的a是局部变量，在出
    //test()函数时就被销毁了
    int main()
    {
        
    	int* p=test();
    	*p=20;
    	return 0;
    }

![在这里插入图片描述][a882246e555a44269f497d06b8fc144e.jpeg_pic_center]

### 如何规律避免野指针 ###

##### 1.指针进行初始化 #####

当前不知道p应该初始化为什么地址的时候，直接初始化为 **NULL**

int* p=NULL;

##### 2.小心指针越界 #####

##### 3.指针指向的空间及时释放 ，既是值为NULL。 #####

free(p);
    p=NULL;

##### 4.指针使用之前检查有效性 #####

int main()
    {
        
    	int* p=NULL;
    	if(p!=NULL)
    	{
        
    		*p=10;
    	}
    	return 0;
    }

**总结：** 一个指针变量不知道指向什么地方地时候，指向空指针。当它指向地空间被释放地时候也指向空指针。  
![在这里插入图片描述][178f49399b95491ab0da3fe9ab639005.jpeg_pic_center]

### 指针减指针 ###

得到是两个指针之间的元素变量个数（两个指针要指向同一块空间）

**一小段strlen函数的实现**

如果不懂可以在这篇博客中理解strlen函数[http://t.csdn.cn/jxemH][http_t.csdn.cn_jxemH]

int my_strlen(char* str)
    {
        
    	char* start=str;
    	//将字符串首地址进行备份
    	while(*str!='\0')
    	{
        
    		str++;
    	}
    	//当没有遇到字符'\0'时，指针向后每次移动一位
    	return str-start;
    }

### 指针的关系运算 ###

标准规定

允许指向数组元素的指针与指向数组最后一个元素，后面的那个内存位置的指针进行比较，但是不允许与指向第一个元素之前的那个内存位置的指针进行比较。

### 数组和指针 ###

int arr[2]={
        0};
    int *p=arr;
    
    //以上*p=arr又可以表示为
    
    arr[2]<==>*(arr+2)<==>*(p+2)<==>*(2+p)<==>*(2+arr)<==>2[arr];

### 二级指针 ###

int main()
    {
        
    	int a=10;
    	int* pa=&a;
    	//pa是指针变量，一级指针
    	int * *paa=&pa;
    	//paa也是个变量，&pa取出pa在内存中起始地址
    	//paa就是一个二级指针变量
    	return 0；
    }

![在这里插入图片描述][03b6dd0727e94038a352088184fe323e.jpeg_pic_center]

## 指针数组 ##

指针数组是一个存放指针的数组。

本质上是数组

int* arr1[10];
    //整形指针的数组
    
    char* arr[4];
    //一级字符指针的数组
    
    char* *arr[5];
    //二级字符指针的数组

## 数组指针 ##

本质上是指针

int arr[10]={
        1,2,3,4,5};
    int (*parr)[10]=&arr;
    //取出的是数组的地址
    //parr就是有一个数组指针  其中存放的是数组的地址
    
    //打印
    printf("%d",*((*pa)+i));

**两者结合一起理解**

int (*parr[10])(5);

parr是一个存储数组的指针的数组，该数组能够存放10个数组指针，每个数组指针能够指向一个数组，数组5个元素，每个元素是int类型。

## 函数指针 ##

存放函数地址的指针

数组名!=&数组名  
但  
函数名=&函数名

自己定义一个函数Add
    int Add(int x,int y)
    {
        
    return x+y;
    }
    //使用
    int (*pf)(int,int)=Add;
    
    三种等价的调用方法
    int ret=(*pf)(3,5);
    
    int ret=pf(3,5);
    
    int ret=Add(3,5)

![在这里插入图片描述][87f0d2fef8ab43e9a921cd310ca3e3b5.jpeg_pic_center]

## 函数指针数组 ##

存放函数的数组

int Add(int x,int y)
    {
        
    return x+y;
    }
    
    int Sub(int x,int y)
    {
        
    return x-y;
    }
    int (*pf1)(int ,int )=Add;
    int (*pf2)(int ,int)=Sub;
    //函数指针数组
    int (*pfArr2)(int, int)={
        pf1,pf2};
    
    //使用
    int ret=(pfArr[input])(x,y);

**解释如何使用：** 这里的input是自己输入的下标，数组小标从0开始，依次增加1；

就以上代码，假设我们输入input为0，那么就会调用pf1,而pf1有指向Add函数，那么就会开始调用这个函数。

#### 小结 ####

//函数指针
    int (*p)(int,int);
    
    //函数指针的数组
    int (*p2[4])(int,int);
    
    //取出的是函数指针数组的地址
    int (*(*p3)[4])(int,int)=&p2;
    //p3是一个指向【函数指针的数组】的指针。

## 回调函数 ##

回调函数就是一个通过函数指针调用的函数。如果你把函数的指针（地址）作为函数传递给另一个函数，当这个指针被调用其所指向的函数时，我们就说这时回调函数。回调函数不是由该函数的实现放直接调用，而是特定的事件或条件发生时由另外的一方调用的，用于对该事件或条件进行响应。

![在这里插入图片描述][6b9e6a9c67b348049bc6cbac0595eef3.jpeg_pic_center]

## 用上面的方法写一个计算器 ##

### 计算机基本函数 ###

#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 menu()
    {
        
    	printf("1.Add\n");
    	printf("2.Sub\n");
    	printf("3.Mul\n");
    	printf("4.Div\n");
    	printf("0.exit\n");
    }

#### 用函数指针数组编写计算器 ####

int main()
    {
        
    	int input=0;
    int x=0,y=0;
    do{
        
    	menu();
    	printf("请进行选择:>");
    	scanf("%d",&input);
    	int(*arr[5])(int,int)={
        NULL,Add,Sub,Mul,Div};
    	//这里第一个位置为NULL的原因
    	//在menu()菜单中0是退出，而在函数指针中NULL为0，退出程序。
    
    	//计算机的数组下标是1~4
    	if(input>=1&&input<=4)
    	{
        
    		printf("请输入两个数:>");
    		scanf("%d %d",&x,&y);
    		int ret=(arr[input])(x,y);
    		printf("%d\n",ret);
    	}
    	else if(input==0)
    	{
        
    		printf("退出程序!");
    	}
    	else 
    	{
        
    		printf("输入错误，请重新输入!");
    	}
    }while(input);
    
    	return 0;
    }

#### 回调函数编写计算器 ####

int Calc(int(*ptr)(int,int))
    {
        
    	int x=0;
    	int y=0;
    	printf("请输入两个数:>");
    	scanf("%d %d",&x,&y);
    	return ptr(x,y);
    }
    int main()
    {
        
    	int input=0;
    	int ret=0;
    	do{
        
    		menu();
    		printf("请选择一个数字:>");
    		scanf("%d",&input);
    		switch(input)
    		{
        
    		case 1:
    			ret=Calc(Add);
    			printf("%d\n",ret);
    			break;
    		case 2:
    		    ret=Calc(Sub);
    			printf("%d\n",ret);
    			break;
    		case 3:
    		    ret=Calc(Mul);
    			printf("%d\n",ret);
    			break;
    		case 4:
    		    ret=Calc(Div);
    			printf("%d\n",ret);
    			break;
    		case 0:
    			printf("退出程序!");
    			break;
    		default:
    			printf("输入错误，请重新输入!");
    			break;
    		}
    	}while(input);
    }

![在这里插入图片描述][b65d351b9a33410cb64f05a7d7f3d2fd.jpeg_pic_center]

## 欣赏两端有趣的代码 ##

(*(void(*)())0)();

**理解代码：**

代码从0这个位置开始看

调用0地址处的函数  
该函数无参，返回类型是Void.

**1.** void(*)()–> 函数指针类型。  
**2.** (void(*)())0 –> 对00进行强制类型转换，被解释为一个函数地址。  
**3.** *(void(*)())0 –> 对0地址进行了解引用操作。  
**4.** (*(void(*)())0)() –> 调用0地址处的函数。

void(*signal(int,void(*)int))(int);

**理解代码：**  
**1.** signal和()先结合，说明signal是函数名。  
**2.** signal函数的第一个参数是int，第二个参数的类型是函数指针，该函数指针指向一个参数为int，返回类型为void的含函数。  
**3.** signal函数的返回类型也是一个函数指针，该函数指针指向一个参数为int，返回类型为void的函数。  
**4.** signal是一个函数的声名。

![在这里插入图片描述][b5a0d75b6cdb4756a97bc591b4f27d15.jpeg_pic_center]  
这两端代码来自《C陷阱与缺陷》

学的不是技术，更是梦想

[6be52d2d452c48beb7aa4016b39fe500.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/06/dd34903593394b578b32c2eeaba8b0e8.png
[2f6ae192c7454486bcbaf24861a71e1e.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/06/213c9eaef9224f08be59d599407ba530.png
[9b293361a84b4e29b808e2a8f0a1b5f5.jpeg_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/06/fce97a84ec214e08929c255ac2332e47.jpeg
[a882246e555a44269f497d06b8fc144e.jpeg_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/06/cb1239a6205640d3b15ca486b912569d.jpeg
[178f49399b95491ab0da3fe9ab639005.jpeg_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/06/80fe00f9a8824c8e9513eaa202a5fbe5.jpeg
[http_t.csdn.cn_jxemH]: http://t.csdn.cn/jxemH
[03b6dd0727e94038a352088184fe323e.jpeg_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/06/01f80e7cab684a60b88ce18461c8eef5.jpeg
[87f0d2fef8ab43e9a921cd310ca3e3b5.jpeg_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/06/435f3760300f40c4a57560a4a987e6a6.jpeg
[6b9e6a9c67b348049bc6cbac0595eef3.jpeg_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/06/0b58472bb1974aef8608bf06641a1fb1.jpeg
[b65d351b9a33410cb64f05a7d7f3d2fd.jpeg_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/06/840a6f7373d542d4b428eb2a6ee36c95.jpeg
[b5a0d75b6cdb4756a97bc591b4f27d15.jpeg_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/06/e54b3f8cbefe4a3a92be9f1d746344fa.jpeg