【C生万物】 指针篇 (初级)

 欢迎来到 Claffic 的博客 💞💞💞                               👉 专栏：《C生万物 | 先来学C》👈

前言：

面对C语言，很多童鞋都会高呼：指针难，指针难，对于我来说，指针是解决问题的一大杀器，是C/C++的灵魂，先不考虑难不难的问题，上了车再说。

---

 

目录

Part1:何为指针

1.概念

2.编址和指针大小

Part2:指针使用

1.类型

2.解引用

Part3:野指针

1.概念

2.成因

2.1指针未初始化

2.2指针越界访问

2.3指针指向的空间释放

3.如何规避

Part4:指针运算

1.指针 +- 整数

2.指针 - 指针

3.指针的运算关系

Part5:指针与数组

Part6:指针数组

Part7:二级指针

---

Part1:何为指针

1.概念

在初始C语言的时候就提到了，指针就是地址，具有指向作用。

这里有指针理解的两个要点：

• 指针是内存中一个最小单元的编号，也就是地址；

• 平时口语中说的指针，通常指的是指针变量，是用来存放内存地址的变量。

总结一下，还是指针就是地址，口语中说的指针就是指针变量。

理解：

内存中的每个字节都是有标号的，称为地址：

（地址以十六进制展示）

考考你，如何取到指针变量呢？

用取地址符号&，在操作符篇已经讲过了。

指针变量：

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

#include <stdio.h>
int main()
{
	int a = 10; // 在内存中开辟一块空间
	int* p = &a; // 使用&操作符，取出变量a的地址
	
	return 0;
}

a 变量占用4个字节的空间，这里是 将 a 的4个字节的第一个字节的地址存放在p变量中

p就是一个指针变量。 

2.编址和指针大小

不知道你注意了吗，上方展示的是一个字节编一个地址，那么为什么这么做呢？

任何软件上的行为都可以归结到硬件上： 

对于32位的机器，假设有32根地址线，

每根地址线在寻址的时候会产生高电压（1）或低电压（0），

32根地址线产生的地址就有：

00000000 00000000 00000000 00000000

00000000 00000000 00000000 00000001

... ...

11111111 11111111 11111111 11111110

11111111 11111111 11111111 11111111

计算一下，这里有2^32个地址，

每个地址标识一个字节，就可以给4GB的空间进行编址。

（一位0/1为一个比特位，1Byte == 8bit）

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

• 在64 位机器上，如果有 64 个地址线，那一个指针变量的大小是 8 个字节，才能存放一个地址。

总结： 

指针变量是用来存放地址的，地址是唯一表示一个内存单元的

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

Part2:指针使用

1.类型

我们知道变量是有类型的，那么指针有类型吗？

答案是肯定的，

如：

p 没有指定类型，所以会爆红。

正确情况应该是：

以下是一些常见的指针类型：

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

可见，指针的定义方式是 type + * + name 

变量的类型与指针的类型是对应的，

如 int* 指针存储 int 类型的变量，char* 指针存储 char 类型的变量。

2.解引用

指针的解引用符号也是 * ，是由地址找到变量的操作。

以上只是笼统的说法，实际上这种说法并不准确。

看下面这段代码：

pc 和 pi 是不同的，区别在于访问的位数不同

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

准确的说法是：
指针的类型决定了对指针解引用的时候有多大的权限（能操作几个字节）。

Part3:野指针

1.概念

野指针就像一条野狗，它面向的位置是随机的

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

 

2.成因

2.1指针未初始化

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

此处就像随机找个房间闯入... ...

2.2指针越界访问

在数组中存在越界访问：

#include <stdio.h>
int main()
{
	int arr[10] = { 0 };
	int* p = arr;
	int i = 0;
	for (i = 1; i <= 11; i++)
	{
		*(p++) = i; // 当i等于11时，数组越界访问
	}

	return 0;
}

当指针指向的范围超出数组arr的范围时，p就是野指针。

2.3指针指向的空间释放

试想，这有一块空间，有个指针指向它，突然这块空间被释放了，

指针不见了空间，那它不就变野了吗？

以上是笼统的说法，具体到动态内存开辟篇讲解

3.如何规避

这里总结几种规避野指针的方法：

• 指针初始化

• 小心指针越界

• 指针指向空间释放，及时置NULL

• 避免返回局部变量的地址

• 指针使用之前检查有效性

敲代码时养成好习惯。

对于检查有效性，这里详细解释下：

#include <stdio.h>
int main()
{
	int* p = NULL;
	int a = 10;
	p = &a;
	if (p != NULL)
	{
		*p = 20;
	}

	return 0;
}

例如这段代码中，要改变 a ，提前用 p 保存了 a 的地址，在访问之前检查一下 p 是否为空，确保指针的有效性。

Part4:指针运算

1.指针 +- 整数

用下面这段代码测试：

#include <stdio.h>
int main()
{
	int n = 10;
	char* pc = (char*)&n;
	int* pi = &n;

	printf("%p\n", &n);
	printf("%p\n", pc + 1); // char*类型的指针
	printf("%p\n", pi);
	printf("%p\n", pi + 1); // int*类型的指针

	return 0;
}

运行结果： 

 

指针 + 1，地址走了多大由指针类型决定。

运用这一点，我们可以这样遍历数组：

int main()
{
	float values[5];
	float* vp;
	for (vp = &values[0]; vp < &values[5];)
	{
		*vp++ = 0; // 后置++，先使用后++
	}

	return 0;
}

2.指针 - 指针

在计算数组长度的场景下可以利用指针 - 指针

模拟 strlen 函数：

int my_strlen(char *s)
{
       char *p = s;
       while(*p != '\0' ) // 数组以 \0 结尾
              p++;
       return p-s;
}

3.指针的运算关系

标准规定：

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

Part5:指针与数组

在数组篇讲过：

• sizeof(数组名)，计算整个数组的大小，内部单独放一个数组名，表示整个数组；

• &数组名，取出的是数组的地址，数组名表示整个数组。

除以上两种情况之外，所有的数组名都表示数组首元素的地址。  

借用下面这段程序解释： 

#include <stdio.h>
int main()
{
	int arr[] = { 1,2,3,4,5,6,7,8,9,0 };
	int* p = arr; // 指针存放数组首元素的地址
	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;
}

 运行结果：

 

嗯，除了利用下标，是不是又会了一种访问数组元素方法呢？

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

运行结果： 

 

  

Part6:指针数组

数组我们是懂的，那么指针数组是什么？

先说指针数组是指针还是数组：

答案是数组，那它有什么特别之处呢？

其实它存储的数据类型是指针，就这里特别。

表示法：

指针类型 + 指针数组名称 + [];

例如：

int* arr[5];

arr 是一个数组，有五个元素，每个元素是一个整形指针。 

 

Part7:二级指针

前面讲的指针都是一级指针，那么什么是二级指针呢？

对的，就是指向指针的指针 / 指针变量的地址

 多一级就多一颗 * 

对二级指针的运算有：

• *ppa 通过对 ppa 中的地址进行解引用，这样找到的是 pa ， *ppa 其实访问的就是 pa

int b = 20;
*ppa = &b;//等价于 pa = &b;

• **ppa 先通过 *ppa 找到 pa , 然后对 pa 进行解引用操作： *pa ，那找到的是 a 

**ppa = 30;
//等价于*pa = 30;
//等价于a = 30;

 

---

总结： 

指针，指针，看完后你应该就觉得指针其实没那么难，学会了它，你就可以处理很多问题，起码还可以装x

码文不易 

如果你觉得这篇文章还不错并且对你有帮助，不妨支持一波哦  💗💗💗