指针的创建和理解
指针理解
我们常说的指针指代的是指针变量
数据在电脑中储存是占内存的，内存以字节位单位，每个字节都有对应的地址，这个地址就是指针
指针的大小
指针大小取决于机器，机器为内存编码和他的地址线数相关
比如三十二位机器，就有三十二根地址线，能够编码的内存大小就是 2^32 = 4GB
指针类型的作用
- 规定每次 ± 整数越过的字节个数（步长）
- 规定间接引用的时候访问的字节数
比如 int* p = &a 每次 p+1 就越过 4个字节， *p 访问四个字节
指针运算
- 指针相减，得到元素距离(没有加法)
- 指针比较
- 指针±整形
野指针
野指针的情况
- 指针的越界访问
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;
}
}
- 指针没有初始化
int main()
{
int *p;
*p = 20;
}
- 指针指向的是释放的空间
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;
}
避免野指针
- 创建指针时候初始化，怕你间址访问的时候忘了
- 如果指针指向的是可释放的空间，在释放后指针要指向NULL
- 避免返回局部变量的值
- 小心数组越界
字符指针（和我以前理解有点不一样 ）
字符指针
- 字符指针存放单个字符
int main()
{
char a = 'w';
char * b = &a;
return 0;
}
- 字符指针指向字符串首元素地址(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;
}
利用类似的将数组首元素的地址放在一个指针数组中，可以模拟二维数组
数组和指针
- 创建一个数组指针并且声明
int main()
{
int a[10] = {0};
int (*p)[10] = &a;
return 0;
}
- 数组指针地址和数组名的区别
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;
}
数组指针的使用
还是可以用来做二维数组的模拟，二维数组不仅可以使用首字母元素，还能用数组指针实现
- 数组名版本
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;
}
- 数组地址版本（不建议这么写）
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;
}
- 数组指针传参
#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);
return 0;
}
- 注意
4.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))
return 0;
}
- 一些特例
2.1 不太明显的函数指针
(*( void (*)() ) 0)();
void (*signal(int , void(*)(int)))(int);
typedef void *p_fun(int);
p_fun signal(int,void(*)(int));
函数指针数组
- 转移表实现计算器
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;
}
总结
- 多情况尝试使用转移表
- 注意数组传参的函数类型，能够辨认一些奇怪的指针写法
- 注意避免野指针的情况
|