c语言学习（六）初始指针

m_yx

已于 2022-07-01 21:58:38 修改

阅读量73

点赞数

分类专栏： c语言学习文章标签： c语言学习

于 2022-05-30 00:32:29 首次发布

本文链接：https://blog.csdn.net/mayu_xuan/article/details/125030781

版权

c语言学习专栏收录该内容

17 篇文章 2 订阅

订阅专栏

1.指针是什么

在计算机科学中，指针是编程语言中的一个对象，利用地址，他的值直接指向存在电脑存储器中另一个地方的值。由于通过地址能找到所需的变量单元，可以说，地址指向该变量单元。因此，将地址形象化的称为“指针”。意思是通过它能找到以它为地址的内存单元。

那我们就可以这样理解：

内存

指针

指针是个变量，存放内存单元的地址（编号）。

那对应到代码：

#include<stdio.h>

int main()
{
	int a = 10; //在内存中开辟一块空间
	int* p = &a; //这里我们对变量a，取出他的地址，可以使用&操作符
				 //将a的地址存放在p变量中，p就是一个指针变量
	return 0;
}

总结： 指针就是变量，用来存放地址的变量。（存放在指针中的值都被当成地址处理）

那这里的问题是：

一个小的单元到底是多大？（一个字节）

如何编址？

经过仔细的计算和权衡我们发现一个字节给一个对应的地址是比较合适的。

对于32为的机器，假设有32根地址线，那么假设每根地址线在寻址的是产生一个电信号正电/负电（1或者0）

那么32根地址线产生的地址就会是：

这里就有2的32次方给地址。

每个地址标识一个字节，那我们就可以给（2^32Byte == 2^3 / 1024KB == 2^32 / 1024 / 1024KB == 2^32/1024/1024/1024GB == 4GB）4G的空闲进行编址。

同样的方法，那64位机器，如果给64根地址线，那能编址多大空间，自己计算。

这里我们就明白：

在32位的机器上，地址是32给0或者1组成二进制序列，那地址就得用4给字节的空间来存储，所以一个指针变量的大小都应该是4个字节。

那如果在64给地址线，那一个指针变量的大小是8给字节，才能存放一个地址。

总结：

指针是用来存放地址的，地址是唯一标识一块地址空间的。

指针的大小在32位平台是4个字节，在64位平台是8给字节。

2.指针和指针类型

这里我们再讨论一下：指针的类型我们都知道，变量有不同的类型，整型，浮点型等。那指针有没有类型你？准确的说，有的。

int num = 10;
p = &num;

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

我们指针定义的方式是：type *，其实，char*类型的指针是为了存放char类型变量的地址，short*类型的指针是为了存放short类型变量的地址，int*类型的指针是为了存放int类型变量的地址。

那指针类型的意义是什么？

指针+-整数

#include<stdio.h>

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;
}

总结：指针的类型决定了指针向前或者香火走一步有多大（距离）。

指针的解引用

#include<stdio.h>

int main()
{
	int a = 0x11223344;
	int* pa = &a;
	*pa = 0; //重点在调试的过程中观察内存的变化
	printf("%p\n", pa);
	char* pc = (char*)&a;
	*pc = 0; //重点在调试的过程中观察内存的变化
	printf("%p\n", pc);
	return 0;
}

总结：指针的类型决定了，对指针解引用的时候有多大的权限（能操作几个字节），比如：char*的指针解引用就只能访问一个字节，而int*的指针的解引用就能访问四个字节。

3.野指针

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

野指针成因

1.指针未初始化

#include<stdio.h>

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

2.指针越界访问

#include<stdio.h>

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.指针初始化

2.小心指针越界

3.指针指向空间释放即使置NULL

4.指针使用之前检查有效性

4.指针运算

指针+-整数

#include<stdio.h>

int main()
{
	float values[5];
	float* vp;
	//指针+-整数，指针的关系运算
	for (vp = &values[0]; vp < &values[5];)
	{
		*vp++ = 0;
	}
	return 0;
}

指针-指针

#include<stdio.h>

int my_strlen(char* s)
{
	char* p = s;
	while (*p != '\0')
	{
		p++;
	}
	return p - s;
}
int main()
{
	char arr[] = "bit";
	int len = my_strlen(arr);
	printf("%d\n", len);
	return 0;
}

指针的关系运算

#include<stdio.h>

int main()
{
	for (vp = &values[5] : vp > &values[0];)
	{
		*--vp = 0;
	}
	return 0;
}

标准规定：

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

5.指针和数组

数组名是什么？我们看一个例子：

#include<stdio.h>

int main()
{
	int arr[20] = { 1,2,3,4,5,6,7,8,9 };
	printf("arr = %p\n", arr);
	printf("&arr[0] = %p\n", &arr[0]);
	return 0;
}

运行结果:

可见数组名和数组首元素的地址是一样的。

结论：数组名表示的是数组首元素的地址。

那么这样写代码是可行的：

int arr[10] = { 1,2,3,4,5,6,7,8,9 };
int* p = arr; //p存放的是数组首元素的地址

既然可以把数组名当成地址存放到一个指针中，我们使用指针来访问一个就成为可能。

例如：

#include<stdio.h>

int main()
{
	int arr[10] = { 1,2,3,4,5,6,7,8,9 };
	int* p = arr; //p存放的是数组首元素的地址
	int sz = sizeof(arr) / sizeof(arr[0]);
	for (int i = 0; i < sz; i++)
	{
		printf("&arr[%d] = %p <====> p+%d = %p\n", i, &arr[i], i, p + i);
	}
	return 0;
}

运行结果：

所以p + i 其实计算的是数组arr下标为i的地址。

那我们就可以直接通过指针来访问数组。

如下：

#include<stdio.h>

int main()
{
	int arr[10] = { 1,2,3,4,5,6,7,8,9,0};
	int* p = arr; //p存放的是数组首元素的地址
	int sz = sizeof(arr) / sizeof(arr[0]);
	for (int i = 0; i < sz; i++)
	{
		printf("%d ", *(p + i));
	}
	return 0;
}