【C语言】指针知识全总结

去看全世界的云

已于 2024-12-31 11:41:10 修改

阅读量5k

点赞数 16

文章标签： c语言

于 2023-11-02 22:55:31 首次发布

本文链接：https://blog.csdn.net/Patrick_yuxuan/article/details/134170782

版权

一.指针是什么

指针(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;指向函数指针数组。

后续内容笔者仍在学习，文章如有错误望您指正。

感谢您的阅读