超全面de关于C语言的指针和数组

指针的创建和理解

指针理解

我们常说的指针指代的是指针变量
数据在电脑中储存是占内存的，内存以字节位单位，每个字节都有对应的地址，这个地址就是指针
指针的大小
指针大小取决于机器，机器为内存编码和他的地址线数相关
比如三十二位机器，就有三十二根地址线，能够编码的内存大小就是 2^32 = 4GB

指针类型的作用

1. 规定每次 ± 整数越过的字节个数（步长）
2. 规定间接引用的时候访问的字节数
   比如 int* p = &a 每次 p+1 就越过 4个字节， *p 访问四个字节

指针运算

1. 指针相减，得到元素距离(没有加法)
2. 指针比较
3. 指针±整形

野指针

野指针的情况

1. 指针的越界访问

int main()
{
	int i = 0;
	arr[10] = {0};
	for(i = 0;i<12;i++)
	{
		arr[i] = i;
	}
}

关于数组的越界，有一个特别的情况:
在比较索引的时候，指针可以走到数组最后一个元素后一位的地址，来和数组最后一个元素比较，但是不建议走到第一个元素前一个地址和数组第一个元素地址比较
比如

int main()
{
	arr[10] = {0};
	int i = 0,j = 0;
	for(i = 0;i<=&arr[9];++i)
	{
		arr[i] = i;//允许
	}
	for(i = 9;i>=&arr;i--)
	{
		arr[i] = i;//可能会出问题
	}
}

2. 指针没有初始化

int main()
{
	int *p;
	*p = 20;
}

3. 指针指向的是释放的空间

int* init(void)
{
	int arr[10] = { 0 };
	int i = 0;
	for (i = 0; i < 10; i++)
	{
		arr[i] = i;
	}
	return arr;
}

int main()
{
	int* a = init();
	int i = 0;
	for (i = 0; i < 10; i++)
	{
		printf("%d",a[i]);//此处函数把地址给了你，但是里面的数据是释放了的,打印一群乱码
	}
	return 0;
}

避免野指针

1. 创建指针时候初始化，怕你间址访问的时候忘了
2. 如果指针指向的是可释放的空间，在释放后指针要指向NULL
3. 避免返回局部变量的值
4. 小心数组越界

字符指针（和我以前理解有点不一样 ）

字符指针

1. 字符指针存放单个字符

int main()
{
	char a = 'w';
	char * b = &a;
	return 0;
}

2. 字符指针指向字符串首元素地址(const 在 * 前表示只读)

int main()
{
	const char * b = "Hello world!";
	printf("%s\n",b);
	return 0;
}

一道判断题

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

最终的结果是
str1 and str2 are not same
因为，创建不同字符串数组，首元素地址不同
str3 and str4 are same
str3 str4 指向的是一个字符串常数，指针指向一个常数的首元素地址，所以地址相同

字符串数组（利用字符指针的性质）

int main()
{
	char* arr[5] = {"abcd","efgh","ijkl","mnop","qrst"};
	//将字符串的首地址储存在指针数组中，然后访问
	int i = 0;
	for(i = 0;i<5;i++)
	{
		printf("%s\n",arr[i]);
	}
	return 0;
}

利用类似的将数组首元素的地址放在一个指针数组中，可以模拟二维数组

数组和指针

1. 创建一个数组指针并且声明

int main()
{
	int a[10] = {0};
	int (*p)[10] = &a;//一个指针 p ,指向的是有 10个元素的整形
	return 0;
}

2. 数组指针地址和数组名的区别
   2.1 数组名和&数组名 的起始值是一样的
   2.2 数组名是数组首元素，&数组名 此时数组名代表整个地址，&数组 可以访问整个数组，&数组 + 1 跳过整个数组
   例子

   #define _CRT_SECURE_NO_WARNINGS 1
   #include<stdio.h>
   int main()
   {
   	int arr[10] = { 0 };
   	int* p_buf = &arr;
   	printf("%p\n", arr);
   	printf("%p\n", p_buf);
   	printf("%p\n", arr + 1);
   	printf("%p\n", p_buf + 1);
   	printf("%d\n", *p_buf);
   	printf("%d\n", *arr);
   	return 0;
   }
   

数组指针的使用

还是可以用来做二维数组的模拟，二维数组不仅可以使用首字母元素，还能用数组指针实现

1. 数组名版本

int main()
{
	int arr1[5] = { 0,1,2,3,4 };
	int arr2[5] = { 5,6,7,8,9 };
	int arr3[5] = { 10,11,12,13,14 };
	int arr4[5] = { 15,16,17,18,19 };
	int* arr[4] = { arr1,arr2,arr3,arr4 };
	int* arr0[4] = { &arr1,&arr2,&arr3,&arr4 };

	int i = 0;
	for (i = 0; i < 4; i++)
	{
		int j = 0;
		for (j = 0; j < 5; j++)
		{
			printf("%2d ", arr[i][j]);
		}
		printf("\n");
	}
	return 0;
}

2. 数组地址版本（不建议这么写）

int main()
{
	int arr1[5] = { 0,1,2,3,4 };
	int arr2[5] = { 5,6,7,8,9 };
	int arr3[5] = { 10,11,12,13,14 };
	int arr4[5] = { 15,16,17,18,19 };
	int* arr[4] = { arr1,arr2,arr3,arr4 };
	int	(*arr0[4])[5] = { &arr1,&arr2,&arr3,&arr4 };//注意这个
	int i = 0,j = 0;
	for (i = 0; i < 4; i++)
	{
		int j = 0;
		for (j = 0; j < 5; j++)
		{
			printf("%2d ", *(**(arr0+i)+j));//第一次 * 得到 数组指针，第二次 * 进入数组 ，第三次 * 得整数
		}
		printf("\n");
	}
	return 0;
}

3. 数组指针传参

#include <stdio.h> 
void print_arr1(int arr[3][5], int row, int col) {
	int i = 0;
	for (i = 0; i < row; i++) {
		int j = 0;
		for (j = 0; j < col; j++)
		{
			printf("%d ", arr[i][j]);
		}
		printf("\n");
	}
}

void print_arr2(int(*arr)[5], int row, int col) 
{
	int i = 0; 
	for (i = 0; i < row; i++) 
	{
		int j = 0;
		for (j = 0; j < col; j++) 
		{
			printf("%d ", arr[i][j]);
		} 
		printf("\n");
	}
}

int main() {
	int arr[3][5] = { 1,2,3,4,5,6,7,8,9,10 }; 
	print_arr1(arr, 3, 5); 
	print_arr2(arr, 3, 5);
	//arr 看成一维数组的话，有三个元素，每个元素是内含五个整形的数组
	//arr + i 就是数组指针
	//所以 print2函数接受的是 数组指针,每个指针指向含有五个整形的数组
	 return 0;
}

4. 注意
   4.1 二维数组不能省略最后一维数组的长度 ，数组二维指针传参时也不能省略

指针数组

1. 顾名思义就是 元素是指针的数组 ，在二维数组实现的数组名版本中有使用

函数指针

1. 创建和初始化 (确定返回值和参数就可以)

int Add(int a,int b)
{
	return a+b;
}
int main()
{
	int (*a)(int ,int) = &Add;
	int (*b)(int,int) = Add;
	//这两种都可以，返回值和参数都相同，只是利用指针储存了罢了
	printf("%d",a(1,2))//a(1,2)利用指针调用函数，也叫回调函数
	return 0;
}

2. 一些特例
   2.1 不太明显的函数指针

(*( void (*)() ) 0)(); 
// 这是一个调用
//void (*)() 是一个函数指针类型，参数是 void 返回值是 void
//那是一个强制类型转换，将 0 转换为 函数指针，然后解引用调用
//意思就是调用地址为 0 处没有 返回值和参数的函数
void (*signal(int , void(*)(int)))(int); 
// 这个是一个创建变量
// signal 是 一个函数指针 参数是 （int,void(*)(int)
//返回值是一个指向返回值void 参数为(int) 的一个函数指针
//等价于
typedef void *p_fun(int);
p_fun signal(int,void(*)(int));

函数指针数组

1. 转移表实现计算器
   1.1：利用 switch 实现
   我们要实现一个计算器，选择加减乘除模式，再输入两个操作数后，能够得到对应的结果，我们可以使用 switch 实现

#define _CRT_SECURE_NO_WARNINGS 1
#include<stdio.h>
int Add(int a, int b)
{
	return a + b;
}
int Sub(int a, int b)
{
	return a - b;
}
int Div(int a, int b)
{
	return a / b;
}
int Mul(int a, int b)
{
	return a* b;
}
void menu()
{
	printf("----1. Add    2.Sub-----\n");
	printf("----3. Mul    4.Div-----\n");
	printf("----     0.exit    -----\n");
	printf("请选择模式:>");
}
int main()
{
	int mod = 1;
	do 
	{
		menu();
		scanf("%d", &mod);
		int x = 0, y = 0;
		switch (mod)
		{
		case 1:
			printf("请输入操作数:>\n");
			scanf("%d %d", &x, &y);
			printf("ret = %d\n", Add(x, y));
			break;
		case 2:
			printf("请输入操作数:>\n");
			scanf("%d %d", &x, &y);
			printf("ret = %d\n", Sub(x, y));
			break;
		case 3:
			printf("请输入操作数:>\n");
			scanf("%d %d", &x, &y);
			printf("ret = %d\n", Mul(x, y));
			break;
		case 4:
			printf("请输入操作数:>\n");
			scanf("%d %d", &x, &y);
			printf("ret = %d\n", Div(x, y));
			break;
		case 0:
			printf("退出程序\n");
			break;
		default:
			printf("输入错误重新输入\n");
			break;
		}

	} while (mod);
	return 0;
}

但是我发现每次 switch 实现都会导致 读取数据和打印数据的功能重复，我们就可以试下将读取数据和打印数据用函数封装起来，随后利用函数指针来调用函数
1.2

#define _CRT_SECURE_NO_WARNINGS 1
#include<stdio.h>
void my_calculator(int mod, int(*fun)(int x, int y), int lens);

int Add(int a, int b)
{
   return a + b;
}
int Sub(int a, int b)
{
   return a - b;
}
int Div(int a, int b)
{
   return a / b;
}
int Mul(int a, int b)
{
   return a* b;
}
void menu()
{
   printf("----1. Add    2.Sub-----\n");
   printf("----3. Mul    4.Div-----\n");
   printf("----     0.exit    -----\n");
   printf("请选择模式:>");
}
void my_calculator(int mod, int(*fun[4])(int x,int y),int lens)
{
   if (mod == 0)
   {
   	printf("退出程序");
   }
   else if (mod > lens)
   {
   	printf("输入错误请重新输入\n");
   }
   else
   {
   	int x = 0, y = 0;
   	printf("请输入操作数:>");
   	scanf("%d %d", &x, &y);
   	int ret = (fun[mod - 1])(x, y);
   	printf("%d\n", ret);
   }
   
}
int main()
{
   int mod = 1;
   int (*fun[4])(int x, int y) = {Add,Sub,Mul,Div};
   do 
   {
   	menu();
   	scanf("%d", &mod);
   	my_calculator(mod, fun, 4);

   } while (mod);
   return 0;
}

---

总结

1. 多情况尝试使用转移表
2. 注意数组传参的函数类型，能够辨认一些奇怪的指针写法
3. 注意避免野指针的情况