文章目录
一.指针是什么
指针(pointer)是一种保存变量地址的变量
我们先分析如下代码
int a=10;
int *ptr;
ptr=&a;
*ptr=5;
int* ptr;表示声明一个指针变量ptr用于存储某个整数变量的指针（即地址）。
*在这里表示声明的变量是一个指针。
int表示指针所指向的类型。
ptr=&a表示ptr指向变量a,存储a的地址。 &(地址运算符)用于取出变量的地址
*ptr=5;*(解引用操作符)后跟一个指针名或地址时，*给出存储在指针指向地址的值。这里表示将5赋值给该指针所指向的变量。
指针其实是地址，但平常我们说指针指的是指针变量
二.指针类型
1.指针类型决定了指针在解引用时访问几个字节
int* 访问四个字节
char* 访问一个字节
double* 访问八个字节
2.指针类型决定指针+1或-1时跳过几个字节
详见指针运算
三.指针所指向的类型
我们可以将声明部分的指针变量名去掉来观察指针指向何类型
例如
char* p = "abcde";//char* 指向char类型变量的指针
int** p2=&p1;//int* 指向指针的指针，二级指针
int* parr[3] = { arr1,arr2,arr3 };//int* [] 指向整数的指针数组
int (*p2)[5] = &arr;//int (*)[] 指向整数的数组指针
四.指针与数组
int*p=arr
下述左侧等价于右侧
&arr[i]<==>p+i
arr[i]<==>*(p+i)
arr[i]<==>*(arr+i)
五.指针数组
指针数组指存放指针的数组
int* arr[5]声明一个存放五个指针的数组
char* ch[5]声明一个存放字符指针的数组
char** arr[5]声明一个存放二级字符指针的数组
我们可以使用指针数组实现二维数组
int arr1[] = { 1,2,3,4,5 };
int arr2[] = { 2,3,4,5,6 };
int arr3[] = { 3,4,5,6,7 };
int* parr[3] = { arr1,arr2,arr3 };
//声明一个指针数组，取一维数组地址。
for (int i = 0; i < 3; i++)
{
int j = 0;
for (j = 0; j < 5; j++)
{
printf("%d ", *(parr[i] + j));//等价于parr[i][j]
}
printf("\n");
}
可以实现二维数组的功能，并且这三个数组在内存上不连续。
六. 指针的算术运算
1.指针与整数相加
指针与整数相加，整数都会和指针指向类型大小（以字节为单位）相乘，然后把结果与初始地址相加。
int main()
{
int arr[5] = { 1,2,3,4,5 };
int* p = arr;
printf("%d ", *p);//1
printf("%d ", *(p+1));//2
}
下图可观察到p与p+1地址相差4，也就是指针指向int类型的大小
因此*(p+1)相当于arr[2]
2.指针与整数相减
得到的绝对值为指针与指针之间的元素个数
与上述相加类似
3.指针与指针相加
指针与指针相加没有意义，就像没人会把日期与日期相加。
4.指针与指针相减
指针求差的两个指针分别指向数组的不同元素，计算出两元素间距离，差值单位与数组类型单位相同。
int main()
{
int arr[5] = { 1,2,3,4,5 };
int* p1 = &arr[4];
int* p2 = &arr[2];
printf("%d ", p1-p2);//2
}
这里得到的2是指数组第三个元素与第五个元素直接相差2个int类型大小的字节，即8字节。
5.数组与整数相加
注意 ：数组名通常表示首元素地址，但有以下两种例外：
1.sizeof(数组名) 中表示整个数组，因此得出的使整个数组的大小；
2.&数组名 也表示整个数组。
对第二种情况做出解释，请看如下代码：
int arr[5] = { 0,1,2,3,4 };
printf("%p\n", arr);
printf("%p\n", arr+1);
printf("%p\n", &arr[0] );
printf("%p\n", &arr[0] + 1);
printf("%p\n", &arr);
printf("%p\n", &arr+1);
第一组与第二组等价，都表示数组的首元素，加1，地址加4个字节；但第三组&arr表示整个数组的地址，加1，表示该数组首元素与整个数组大小相加，在内存上有68变为7c，共20个字节。
七.野指针
野指针产生的原因
1.未初始化，为随机值，非法访问内存；
2.指针越界访问（超出数组下标）；
3.指针指向空间释放。
避免野指针的方法
1.使用空指针时判断是否为空指针；
if (p != NULL)
{*p = 100;}
2.指针初始化；
3.小心指针越界；
4.避免返回局部变量地址；
5.使用前检查有效性；
八.二级指针
二级指针是存放一级指针变量指针的地址
int main()
{
int a = 10;
int* pa = &a;
int** ppa = &pa;
}
int** ppa = &pa要理解这段代码可以使用上文的方法，先看看ppa指向的类型，去掉指针变量名得到int* =&pa，可以看到，ppa指向一个int*类型的变量，即pa的指针。
九.const与指针
const int *ptr与int* const ptr
const int *ptr1.ptr值可变，即可以让ptr指向其他变量；2.不可通过ptr修改其所指向数据的值
int* const ptr1.ptr值不可变，不能让ptr指向其他变量；2.但可通过ptr修改其所指向对象的值
笔者总结如下
远离随意指向，原对象值不变；靠近指向唯一，原对象值可变
需注意原对象值可变与否指的是是否能用const修饰的指针来更改原对象的值。
十.字符指针
char* p="hello";
printf("%S",p);//hello
printf("%c",*p);//h
这里的p是该字符数组的首元素地址,实际上是通过字符指针访问该字符串。
十一.数组指针
数组指针指的是数组名的指针，即数组首元素地址的指针。
int (*p)[10] p即为指向数组的指针，又称数组指针。
int main()
{
int arr[5] = { 0 };
int(*p)[5] = &arr;
}
[]优先级高于*，所以给*加上括号。
p指向一个内含五个Int类型值的数组。
分析如下示例:
int arr[] = { 1,2,3,4,5,6,7,8,9,10 };
int(*p1)[10] = &arr;
for(int i=0;i<10;i++)
{
printf("%d ", *(*p1 + i));
}
p1为&arr
*p1为arr,
*p1 + i为数组首元素地址加i乘int类型大小字节得到的地址
*(*p1 + i)相当于*(arr+i)相当于arr[i]
分析如下二维数组
int main()
{
int arr[3][4] = { 1,2,3,4,2,3,4,5,3,4,5,6 };
int(*p)[4] = &arr;
printf("%p %p\n", p, p + 1);
printf("%p %p\n", p[0], p[0] + 1);
}
可以发现 p, p + 1相差16字节，p[0], p[0] + 1相差4字节。
因此可知虽然数组指针的地址是数组首元素地址，但实际上指的是二维数组第一行首元素的地址，所以跨越了一行4个int类型的元素也就是16字节。
观察如下二维数组
void print(int(*p)[5], int row, int cow)
{
int i = 0;
int j = 0;
for (i = 0; i < row; i++)
{
for (j = 0; j < cow; j++)
{
printf("%d ", *((*p+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, };
print(arr, 3, 5);
}
*((*p+i)+j) 相当于arr[i][j]
*p+i找到行
*(()+j) 找到列
十二.数组参数，指针参数
test(int arr[])
test(int* arr)
test(int arr[10])
int main()
{
int arr[10] = { 0 };
test(arr);
}
对于一维数组上述三种均可
test(int arr[][4])
test(int arr[3][4])
test(int(*p)[4])
int main()
{
int arr[3][4] = {0};
test(arr);
}
二维数组行可省略，列不可省略。
也可使用数组指针来接收
十三.函数指针
函数指针是指指向函数的指针
&函数名和函数名都指函数的地址
int ADD(int x, int y)
{
return x + y;
}
int main()
{
printf("%p\n", ADD);
printf("%p\n", &ADD);
}
观察如下代码
int ADD(int x, int y)
{
return x + y;
}
int main()
{
int (*pf)(int, int) = &ADD;
printf("%p\n", &ADD);
//int ret = (*pf)(2, 3);
int ret = pf(2, 3);
printf("%d\n", ret);
}
一个加法函数，需要两个int类型变量，返回类型为int，可以声明其指针为int (*pf)(int, int) = &ADD;分别表示返回类型，*指针名，函数各参数类型
int ret = (*pf)(2, 3); 等价于int ret = pf(2, 3);，可以不加*。
那么什么情况下要使用函数指针呢
int ADD(int x, int y)
{
return x + y;
}
void calc(int(*pf)(int, int))
{
int a = 3;
int b = 5;
int ret = pf(a, b);
printf("%d\n", ret);
}
int main()
{
calc(ADD);
return 0;
}
在main函数中，调用了calc函数，并将ADD函数作为参数传递给它。这样，calc函数内部就能够使用ADD函数。我们可以将函数作为参数（也就是函数的地址）传递给其他函数，从而能够在calc函数中使用ADD函数。
十四.函数指针数组
存放函数指针的数组
需注意所存放的函数格式应相同，也就是说传入参数个数类型，返回类型都应相同。
#include<stdio.h>
int add(int a, int b)
{
return a + b;
}
int subtract(int a, int b)
{
return a - b;
}
int multiply(int a, int b)
{
return a * b;
}
int divide(int a, int b)
{
return a / b;
}
int main()
{
int (*arr[4])(int, int) = { add ,subtract ,multiply ,divide };//函数指针的数组
int i = 0;
for (i = 0; i < 4; i++)
{
int ret = arr[i](8, 4);
printf("%d ", ret);
}
}
来看主函数，声明一个函数指针的数组，声明方法与函数指针类似，但需在函数明后加上[]来表明为数组指针，分别放入加减乘除四个函数的函数名。
函数指针数组有何用呢
看一个经典的实现计算器功能的代码
#include <stdio.h>
int add(int a, int b)
{
return a + b;
}
int subtract(int a, int b)
{
return a - b;
}
int multiply(int a, int b)
{
return a * b;
}
int divide(int a, int b)
{
return a / b;
}
void menu()
{
printf("*****************************************\n");
printf("******* 1.add 2.subtract *********\n");
printf("******* 3.multiply 4.divide *********\n");
printf("******* 0.exit *********\n");
printf("*****************************************\n");
}
int main()
{
int input = 0;
int a = 0;
int b = 0;
int ret = 0;
int (*arr[5])(int, int) = { 0,add ,subtract ,multiply ,divide };
do
{
menu();
printf("请输入:>");
scanf("%d", &input);
if(input>0 && input<=4)
{
printf("请输入两数:>");
scanf("%d %d", &a, &b);
int ret = arr[input](a, b);
printf("结果为:>%d\n", ret);
}
else if (input == 0)
{
printf("退出计算器\n");
break;
}
else
{
printf("选择错误\n");
}
} while (input);
return 0;
}
在这段代码中，我们声明了一个函数指针数组来调用四个运算函数，帮助我们减化了代码，省去了重复步骤。
同时我们令该数组第一个元素为0，这样可以使得input与下标对应。
不使用函数指针数组，则需要switch来对input进行选择，来找到要调用的函数。
指向函数数组指针的指针
int (*parr[5])(int, int) = { 0,add ,subtract ,multiply ,divide };
int (*(*pparr[5]))(int, int) = &parr;
根据找指针指向类型的方法，去掉指针名，可发现int (*(*[5]))(int, int) = &parr;指向函数指针数组。
后续内容笔者仍在学习，文章如有错误望您指正。
感谢您的阅读
2万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
