C语言指针超详细讲解上篇

目录

• 前言
• 1、指针是什么
• 1.1 指针变量
• 1.2 指针是内存中一个最小单元的编号
• 2、指针和指针类型
• 2.1 指针±类型
• 2.2 指针的解引用
• 2.2.1 int* 类型的解引用
• 2.2.2 char* 类型的解引用
• 3、野指针
• 3.1 野指针成因
• 3.1.1 指针未初始化
• 3.1.2 指针越界访问
• 3.1.3 指针指向的空间释放
• 3.2 如何规避野指针
• 总结

前言

本文开始指针相关内容的学习，主要内容包括：

• 指针是什么
• 指针和指针类型
• 野指针
• 指针运算
• 指针和数组
• 二级指针
• 指针数组

1、指针是什么

指针理解的2个要点：

• 平时口语中说的指针，通常指的是指针变量，是用来存放内存地址的变量
• 指针是内存中一个最小单元的编号，也就是地址

1.1 指针变量

我们可以通过&（取地址操作符）取出变量的内存其实地址，把地址可以存放到一个变量中，这个变量就是指针变量：

int main()
{
	int a = 1;//在内存中开辟一块空间
	//a变量占用4个字节的空间，这里是将a的4个字节的第一个字节的地址存放在p变量中，p就是一个指针变量
	int* pa = &a;//这里我们对变量a，取出它的地址，可以使用&操作符
	printf("%p\n", &a);
	printf("%p\n", pa);
	a = 10;
	printf("%p\n", &a);
	return 0;
}

利用内存和监视来查看&a 和pa的变化：

见下图所示：

• &a为取变量a的地址：0x00CFFEE0
• pa是指针变量，存放的值是变量a的地址: 0x00CFFEE0

a变量占用4个字节的空间，下图在内存中能看到a的地址占用了4个字节，存放 00 00 00 01

内存显示列数可根据自己调节，4列就是4个字节放一行，见下图：

对a重新赋值10，变量a的值发生变化，但地址是不变的。

因此，指针变量，用来存放地址的变量。（存放在指针中的值都被当成地址处理）。

1.2 指针是内存中一个最小单元的编号

• 指针是内存中一个最小单元的编号，这个最小单元是一个字节
• 经过专家们仔细的计算和权衡后，发现一个字节给一个对应的地址是比较合适的
• 对于32位的机器，假设有32根地址线，那么假设每根地址线在寻址的时候产生高电平（高电压）和低电平（低电压）就是（1或者0），32根地址线产生的地址就是：

00000000 00000000 00000000 00000000
00000000 00000000 00000000 00000001
...
11111111 11111111 11111111 11111111

内存最小单元即一个字节，与其对应的地址见下图：

因此，32位的机器就有2的32次方个地址。每个地址标识一个字节，那我们就可以给 ：

2^32 Byte == 2^32/1024 KB == 2^32/1024/1024 MB == 2^32/1024/1024/1024 GB == 4 GB

4 GB的空闲进行编址。同样的方法，那64位机器，如果给64根地址线，那能编址 8 GB 空间。

• 在32位的机器上，地址是32个0或者1组成二进制序列，那地址就得用4个字节的空间来存储，所以一个指针变量的大小就应该是4个字节
• 在64位机器上，有64个地址线，那一个指针变量的大小是8个字节，才能存放一个地址
• 指针是用来存放地址的，地址是唯一标示一块地址空间的
• 指针的大小在32位平台是4个字节，在64位平台是8个字节

int main()
{
	int a = 10;
	int* pa = &a;
	char ch = 'a';
	char* pc = &ch;
	printf("%d\n", sizeof(pa));//4
	printf("%d\n", sizeof(pc));//4
	return 0;
}

上例说明，不管什么类型的指针变量，它的大小就是4个字节。因为地址是32位0 1表示的，而指针变量就是存放地址的变量，需要4个字节存放。跟他的类型无关。

2、指针和指针类型

变量有不同的类型，整形，浮点型等。那指针同样也有类型：

int num = 10;
p = #//num的地址保存到 p

要将&num（num的地址）保存到 p 中，我们知道 p 就是一个指针变量，那它的类型是怎样的呢？我们给指针变量相应的类型

char *pc = NULL;
int *pi = NULL;
short *ps = NULL;
long *pl = NULL;
float *pf = NULL;
double *pd = NULL;

指针的定义方式是： type + *

• char* 类型的指针是为了存放 char 类型变量的地址：即地址里面的变量是char 类型，占用1个字节，地址本身4个字节
• short* 类型的指针是为了存放 short 类型变量的地址：即地址里面的变量是short类型，占用1个字节，地址本身4个字节
• int* 类型的指针是为了存放 int 类型变量的地址：即地址里面的变量是 int 类型，占用4个字节，地址本身4个字节

2.1 指针±类型

int main()
{
	int n = 10;
	char *pc = (char*)&n;
	int *pi = &n;
	printf("%p\n", &n);
	printf("%p\n", pc);
	printf("%p\n", pc+1);
	printf("%p\n", pi);
	printf("%p\n", pi+1);
	return 0;
}

指针的类型决定了指针向前或者向后走一步有多大（距离）：

• int *向后+1，就是移动到下一个 int 类的变量的地址，就是移动4个字节
• char *向后+1，就是移动到下一个 char 类型的变量的地址，就是移动1个字节
• 指针的类型，是指向地址里存储数值的类型

2.2 指针的解引用

指针的类型决定了，对指针解引用的时候有多大的权限（能操作几个字节）

2.2.1 int* 类型的解引用

int main()
{
	int a = 0x11223344;
	int* pa = &a;
	*pa = 0;
	return 0;

int* 的指针的解引用就能访问四个字节：

2.2.2 char* 类型的解引用

int main()
{
	int a = 0x11223344;
	char* pa = (char*)&a;//&a是int*，所以在这里强制转换
	*pa = 0;

	return 0;
}

char* 的指针解引用就只能访问一个字节：

3、野指针

野指针就是指针指向的位置是不可知的（随机的、不正确的、没有明确限制的）

3.1 野指针成因

3.1.1 指针未初始化

int main()
{
	int *p;//局部变量指针未初始化，默认为随机值
	*p = 20;
	return 0;
}

3.1.2 指针越界访问

int main()
{
	int arr[10] = {0};
	int *p = arr;
	int i = 0;
	for(i=0; i<=11; i++)//超过数组的元数个数
	{
		//当指针指向的范围超出数组arr的范围时，p就是野指针
		*(p++) = i;
	}
	return 0;
}

3.1.3 指针指向的空间释放

int* test()
{
	int a = 10;
	printf("%d\n", a);
	return &a;//开辟的空间已经释放了
}
int main()
{
	int* p = test();//函数调用结束后，开辟的内存空间释放了
	*p = 100;
	return 0;
}

3.2 如何规避野指针

• 指针初始化
• 小心指针越界
• 指针指向空间释放即使置NULL
• 避免返回局部变量的地址
• 指针使用之前检查有效性

int main()
{
	int *p = NULL;//初始化
	//....
	int a = 10;
	p = &a;
	if(p != NULL)
	{
		*p = 20;
	}
	return 0;
}

总结

本文学习了指针的部分内容，下一篇继续学习指针的内容。

到此这篇关于C语言指针超详细讲解上篇的文章就介绍到这了,更多相关C语言 指针内容请搜索我们以前的文章或继续浏览下面的相关文章希望大家以后多多支持我们！