一、认识指针

在认识指针之前我们先要了解的是“内存”。
一般在购买电脑的时候我们会很在意“内存”的大小一般电脑的“内存”大小有4G、8G或者16G
他们之间的换算方式是

1 TB = 1024 GB
1 GB =1024 MB
1 MB = 1024KB
1 KB = 1024B字节
1 B = 8 b位

程序在运行的时候会在“内存”中被调用运行时占用“内存”的空间。
“内存”就好比一个大房子里面有很多房间为了能快速找到“内存”里面的值我们给每个房间一个编号这就是“内存编号”,这样就可以通过编号找到相应的值。

编号也被称为地址不同“内存”大小的电脑地址编号表示不同假如32位的电脑它就会有32根地址线那么假设每根地址线会产生高电平高电压和低电平低电压我们用1表是高电压0表示低电压。
这样就产生了:
0000 0000 0000 0000 0000 0000 0000 0000~1111 1111 1111 1111 1111 1111 1111 1111种可能。
转化为16进制显示就是0x00000000~0xFFFFFFFF用二进制显示太多了下图也是用16进制显示不影响结果只是表现形式不同罢了

那么指针是什么呢

1. 指针是内存中一个最小单元的编号也就是地址
2. 一般我们说的指针通常指的是指针变量是用来存放内存地址的变量

我们通常口头上说的指针是指指针变量,那么指针变量是什么呢
指针变量也是一种变量只不过是用来存储地址的变量。
我们可以通过&取地址操作符取出变量的“内存编号”把地址可以存放到一个变量中这个变量就是指针变量。
例如
当我们定义一个整形变量a的时候。我们可以将a的地址存在一个指针变量p中由于int占用四个字节所以他有四个编号电脑会存储其中最小的地址假设首地址0X0000EF04.

#include <stdio.h>
int main()
{
	int a = 4;
	int* p = &a;//定义一个整形的指针并指向变量a。
	printf("%p\n", &a);
	printf("%p", p);
	return 0;
}

图解:假设a的地址

实际在64位机器下a的地址:

指针大小
在32位的电脑上地址是32个0或者1组成二进制序列那地址就得用32 b位=4 B字节的空间来存储所以
一个指针变量的大小就应该是4个字节。
那如果在64位机器上如果有64个地址线会有64个位64 b=8 B字节的空间来存储地址
那一个指针变量的大小是8个字节才能存放一个地址。
总结

指针变量是用来存放地址的地址是唯一标识一个内存单元的。
指针的大小在32位平台是4个字节在64位平台是8个字节。

二、指针的类型

指针变量也是变量我们在介绍变量的时候讲了变量有很多类型。那么指针变量也是如此。
当我们需要指向不同类型的变量时就需要创建不同类型的指针变量。

注意:!!!
指针的大小与指针的类型无关因为指针本质是用于存放被指向变量的地址而地址的大小与计算机有关32位或者64位…
下面是在64位机器下运行时观察不同类型的指针变量大小。

补充指针是很危险的因为它可以直接通过地址访问内存我们在初始化指针的时候当我们暂时还不明确要指向哪个变量的时候我们可以将其初始化为空指针(NULL)。防止其访问非法的内存空间。

#include <stdio.h>
int main()
{
	char* p1 = NULL;//创建一个char类型的指针,并初始化为空指针
	int* p2 = NULL;//创建一个int类型的指针,并初始化为空指针
	short* p3 = NULL;
	long* p4 = NULL;
	float* p5 = NULL;
	double* p6 = NULL;
	//计算指针变量的大小
	printf("p1=%dp2=%d, p3=%d, p4=%d, p5=%d, p6=%d", sizeof(p1), sizeof(p2), sizeof(p3), sizeof(p4), sizeof(p5), sizeof(p6));
	return 0;
}

运行结果

p1=8p2=8, p3=8, p4=8, p5=8, p6=8

2.1 指针类型的作用

从上面的代码我们可以知道不同类型的指针大小相同那么指针的类型还有什么意义呢
还是代码容易解释:
🌰栗子

#include <stdio.h>
int main()
{
	int n = 10;
	char* p1 = (char*)&n;//将int类型地址强制转化为char类型
	int* p2 = &n;

	printf("n的地址是	%p\n", &n);
	printf("p1:		%p\n", p1);
	printf("p1+1:		%p\n", p1 + 1);
	printf("p2:		%p\n", p2);
	printf("p2+1:		%p\n", p2 + 1);
	return 0;
}

运行结果

n的地址是      00000032FAAFFA24
p1:             00000032FAAFFA24
p1+1:           00000032FAAFFA25
p2:             00000032FAAFFA24
p2+1:           00000032FAAFFA28

图解

所以不同类型的指针变量决定了指针向前或者向后走一步有多大距离即所谓步长。

2.2 指针的解引用

我们知道指针保存被指向变量的地址那么指针的作用是什么呢
其实我们可以通过指针保存的地址来访问内存中的目标变量并将其修改。这就需要使用指针的解引用操作.

🌰栗子

补充知识: "%x"表示打印结果按照16进制打印,#表示打印前导符0X.

#include <stdio.h>
int main()
{
	int a = 0x11223344;
	int b = 0x11223344;
	int* p1 = &a;
	char* p2 = (char*)&b;
	//p1和p2都是指针里面的内容是地址。
	//*p1是对指针解引用即访问该地址所存储的变量。
	*p1 = 0;
	*p2 = 0;
	printf("%#x\n", a);
	printf("%#x", b);
	return 0;
}

运行结果:

0
0x11223300

结果分析:
因为p1是 int型指针变量,所以能访问四个字节的空间,p1 = 0,将a的值修改为0;
但是p2*是char类型指针变量 所以能访问一个字节的空间 ,所以只能修改b变量中 所以能访问一个字节的数据,至于为何是修改存储44这个字节的数据,就要涉及数据存储时字节的存储顺序知识了,在数据存储时,后面会讲到大小端的知识.现在我们只需要知道,char类型指针只能操作一个字节空间的数据就行了.

总结

1.指针的类型决定指针加减整数时所跳过的步长.
2.指针的类型决定了对指针解引用的时候有多大的权限能操作几个字节。

比如 char* 的指针解引用就只能访问一个字节而 int* 的指针的解引用就能访问四个字节。

三、野指针

野指针指 指针指向的位置是不可知的随机的、不正确的、没有明确限制的指针。
野指针是很危险的它访问的空间不可知、
野指针出现的可能情况有

• 指针未初始化
• 指针越界或者非法访问。
• 指针指向的空间被释放了。例如局部变量

🌰栗子(注意:下段代码是三种情况,此处是将他们写在了一个mian函数中.)

#include <stdio.h>
int main()
{
	//情况1指针未初始化
	int* p1;//指针未初始化
	*p1 = 5;//在不知道指针指向的空间在哪时强行改变指向空间的地址。
	//此时p1就是一个野指针。



	//情况2指针越界访问
	int arr[5] = { 1,2,3,4,5 };
	int i = 0;
	int *p2 = arr;//p指向数组的首地址
	for (i = 0; i <= 10; i++)
	{
		printf("%d\n", *(p2++));
	}
	//当p2指向的空间超过数组的最后一个元素时指针就非法访问即越界访问了未知空间。
	//此时p2是野指针。



	//情况3指向的空间被释放了
	int j = 0;
	for (j = 0; j < 5; j++)
	{
		int a = 5;
		a += 1;
	}
	int* p3 = &a;//当循环结束之后局部变量a向内存申请的空间就被释放了。
	//此时p3指针指向的空间就是已经被释放掉的空间。p3就是野指针。

	return 0;
}

我们知道了野指针的危险,那么如何避免野指针的出现.

1. 指针初始化时明确指向的内容,不明确时设置为空指针.
2. 小心指针越界:使用指针是,仔细检查,指针是否会有越界的情况发生.
3. 指针指向空间释放及时置NULL
4. 避免返回局部变量的地址
5. 指针使用之前检查有效性

四、指针的运算

4.1 指针加减整数

🌰栗子一维数组的打印

#include <stdio.h>
int main()
{
	int arr[6] = { 1,2,3,4,5,6 };
	int sz = 0, i = 0;
	int* p = arr;//定义一个整形指针指向arr数组的首元素
	sz = sizeof(arr) / sizeof(arr[0]);//计算元素的个数
	for (i = 0; i < sz; i++)
	{
		printf("%d ", *p + i);
	}
	return 0;
}

4.2 指针-指针

🌰栗子:自定义字符串长度计算函数

#include <stdio.h>
int my_strlen(const char* right)
{
	char *left = right;//保存数组的首元素地址
	while (*(right)!='\0')//指向'\0'
	{
		right++;
	}
	return right - left;//指向'\0'的指针-指向首元素的指针
}
int main()
{
	char c[] = { "primary-cattle still needs to study hard !" };
	int sz=my_strlen(c);
	printf("%d\n", sz);
	return 0;
}

图解:

指针-指针=元素之间的个数.

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

五、二级指针

指针1是一种用来存放地址的变量,那么是变量也就有地址,所以指针也是有地址的.
当我们再创建一个指针2指向该指针1时 ,指针2就被称为2级指针.

#include <stdio.h>
int main()
{
	int a = 66;
	int* p1 = &a;
	int** p2 = &p1;//p2就是二级指针,指向p1
	**p2 = 4;
	printf("%d", a);
	return 0;
}

运行结果:

4

结果分析:
首先,int* p1 = &a;表示将,a的地址存放在指针p1中,
其次int** p2 = &p1;表示将p1的地址存放在p2指针中.
通过一次解引用找到p1,第二次解引用找到a,将其修改为4.
注意这两个’‘(星号)代表的意思,int * * p,第一个’‘(星号)代表被指向的对象是一个int类型,第二个’’(星号)表示p2是一个指针.
图解:

以此类推,还有三级指针和其他多级指针,常见的指针多为一级指针和二级指针,其他的几乎遇见不到.
好了,今天有关c语言中指针的基础知识就讲到这里了,相信大家对指针有所了解了,后续会将指针更深层的理解.
码文不易,来一个一键三连吧 !✨✨✨
感觉支持!!!💗💗💗