当前位置：网站首页>【C语言】初识指针

在计算机科学中，指针（Pointer）是编程语言中的一个对象，利用地址，它的值直接指向（points to）存在电脑存储器中另一个地方的值。
由于通过地址能找到所需的变量单元，可以说，地址指向该变量单元。因此，将地址形象化的称为“指针”。意思是通过它能找到以它为地址的内存单元。
假设内存块为一栋大楼，每个内存单元为一间房子，每个指针就好比每间房子的门牌号，我们通过门牌号找到相应的房子，同理，我们可以通过指针找到相应的内存单元。

指针理解的2个要点：
1. 指针是内存中一个最小单元的编号，也就是地址
2. 平时口语中说的指针，通常指的是指针变量，是用来存放内存地址的变量
总结：指针就是地址，口语中说的指针通常指的是指针变量
指针变量
我们可以通过&（取地址操作符）取出变量的内存其实地址，把地址可以存放到一个变量中，这个变量就是指针变量

例如：

#include<stdio.h>
int main()
{
	int a = 5;//在内存中开辟一块空间用来存放a
	int* p = &a; //这里我们对变量a，取出它的地址，可以使用& 操作符。
	//p 拿到了 a 的地址，把 a 的地址存放在变量 p 中，p就是一个指针变量
	//对 p 进行解引用操作（也就是 *p）就能找到 a 的地址,相当于拿到了a
	printf("%d\n", a);
	printf("%d\n", *p);

	*p = 10;//对指针变量 p 进行解引用拿到 a 的地址，并对 a 的值进行了间接修改
	printf("%d\n", a);
	printf("%d\n", *p);
	return 0;
}

结果如下：

如上图示：可以说 *p 就相当于 a

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

2、指针的背后

地址如何编址？
经过仔细的计算和权衡我们发现一个字节给一个对应的地址是比较合适的。
对于32位的机器，假设有32根地址线，那么假设每根地址线在寻址的时候产生高电平（高电压）和低电平（低电压）就是（1或者0）；

那么32根地址线产生的地址就会是：
00000000 00000000 00000000 00000000
00000000 00000000 00000000 00000001
00000000 00000000 00000000 00000002
...
11111111 11111111 11111111 11111110
11111111 11111111 11111111 11111111
这里就有 2 的 32 次方个地址。
每个地址标识一个字节，那我们就可以给 4G 的空闲进行编址
（2^32Byte == 2^32/1024KB ==2^32/1024/1024MB==2^32/1024/1024/1024GB == 4GB）

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

二、指针和指针类型

1、指针的类型

这里我们在讨论一下：指针的类型
我们都知道，变量有不同的类型，整形，浮点型等。那指针有没有类型呢？
准确的说：有的。
当有这样的代码：
int num = 10;
p = &num;
要将&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 类型变量的地址。
short* 类型的指针是为了存放 short 类型变量的地址。
int* 类型的指针是为了存放 int 类型变量的地址

2、指针类型的意义

1）指针 +、 - 整数（加减）
#include <stdio.h>
int main()
{
	int n = 10;
	char* pc = (char*)&n;//强制转换成 char 类型
	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;
}
猜猜答案是多少，结果是：
char* 类型的指针 pc+1 结果跳过了一个字节
int* 类型的指针 pi+1 结果跳过了四个字节（环境为 x86）
这说明了指针的类型决定了指针向前或者向后走一步有多大（距离）
2）指针的解引用
#include <stdio.h>
int main()
{
	int n = 0x11223344;
	char* pc = (char*)&n;
	int* pi = &n;
	*pc = 0; //重点在调试的过程中观察内存的变化。
	*pi = 0; //重点在调试的过程中观察内存的变化。

	return 0;
}
猜猜这过程中的变化：
没赋值为 0 之前
*pc 赋值为 0 之后
*pc 赋值为 0 之后，n 中的值只有一个字节被改成了 0
*pi 赋值为 0 之后;
*pi 赋值为 0 之后，n 中的所有字节均被改成了 0
这说明了：指针的类型决定了，对指针解引用的时候有多大的权限（能操作几个字节）。
比如： char* 的指针解引用就只能访问一个字节，而 int* 的指针的解引用就能访问四个字节

指针类型的意义总结：
1、指针的类型决定了指针向前或者向后走一步有多大（距离）。
2、指针的类型决定了，对指针解引用的时候有多大的权限（能操作几个字节）

三、野指针

概念：野指针就是指针指向的位置是不可知的（随机的、不正确的、没有明确限制的）
1、野指针成因
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）指针指向的空间释放
这里放在动态内存开辟的时候讲解，这里可以简单提示一下。
2、如何规避野指针
1. 指针初始化
2. 小心指针越界
3. 指针指向空间释放即使置NULL
4. 避免返回局部变量的地址
5. 指针使用之前检查有效性

四、指针运算

指针 +- 整数
1、指针 + 指针
#include<stdio.h>
#define N_VALUES 5

int main()
{
	float values[N_VALUES];//float 类型的数组
	float* vp;

	//指针+-整数；指针的关系运算
	for (vp = &values[0]; vp < &values[N_VALUES];)
	{
		*vp++ = 0;
	}

	return 0;
}
解释，这个例子将数组中各个单元的值加1。由于每次循环都将指针 vp 加 1 个单元，所以每次循环都能访问数组的下一个单元。
2、指针 - 指针
#include<stdio.h>

int my_strlen(char* s)
{
	char* p = s;
	while (*p != '\0')
		p++;

	return p - s;
}
int main()
{
	char s[] = "abcdef";
	int ret = my_strlen(s);
	printf("%d\n", ret);

	return 0;
}
猜猜结果是什么
结果说明了指针 - 指针得到的是指针和指针之间的元素个数
但是，要注意；
指针 - 指针的前提是，两个指针必须指向同一块空间
3、值得注意
指针和指针进行加减：两个指针不能进行加法运算，这是非法操作，因为进行加法后，得到的结果指向一个不知所向的地方，而且毫无意义。
两个指针可以进行减法操作，但必须类型相同，一般用在数组方面，不多说了
标准规定：
允许指向数组元素的指针与指向数组最后一个元素后面的那个内存位置的指针比较，但是不允许与指向第一个元素之前的那个内存位置的指针进行比较。

五、指针和数组

数组----是一块连续的空间，里面存放的是相同类型的元素，存储的方式是先使用低地址的空间，再使用高地址的空间
指针（变量）--- 是一个变量，存放的是地址
我们看一个例子：
#include <stdio.h>
int main()
{
	int arr[10] = { 1,2,3,4,5,6,7,8,9,0 };

	printf("%p\n", arr);
	printf("%p\n", &arr[0]);

	return 0;
}
结果如下:
可见数组名和数组首元素的地址是一样的。
结论：数组名表示的是数组首元素的地址。（2种情况除外，这里不多讲，指针进阶的时候会详细解答，之前数组也讲到一些)
那么这样写代码是可行的：
int arr[10] = {1,2,3,4,5,6,7,8,9,0};
int *p = arr;//p存放的是数组首元素的地址
既然可以把数组名当成地址存放到一个指针中，我们使用指针来访问一个就成为可能。
例如：
#include <stdio.h>
int main()
{
	int i = 0;
	int arr[] = { 1,2,3,4,5,6,7,8,9,0 };
	int* p = arr; //指针存放数组首元素的地址
	int sz = sizeof(arr) / sizeof(arr[0]);
	for (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[] = { 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;
}
运行结果：

六、二级指针

指针变量也是变量，是变量就有地址，那指针变量的地址存放在哪里？
如图，这就是二级指针
对于二级指针的运算有：
*pa 通过对pa中的地址进行解引用，这样找到的是 b ， *pa 其实访问的就是 b
**ppa 先通过 *pa 找到 pa ,然后对 pa 进行解引用操作： *pa ，那找到的是 b
int b = 20;
*pa = &b; //pa是指针变量（一级指针）
**ppa = &pa; ///ppa是一个二级指针

七、指针数组

指针数组是指针还是数组？
答案：是数组。是存放指针的数组。
数组我们已经知道整形数组，字符数组。
int arr1[5];
char arr2[6];
那指针数组是怎样的？
int* arr3[5];//是什么？
arr3是一个数组，有五个元素，每个元素是一个整形指针

八、总结一下

int p；//这是一个普通的整型变量
int *p； //首先从 p 处开始先与 * 结合,所以说明 p 是一个指针，然后再与int 结合，说明指针所指向的内容的类型为int 型；所以 p 是一个返回整型数据的指针
int **p； //首先从 p 开始,先与*结合,说是 p 是一个指针（*p）；然后再与 * 结合；说明指针所指向的元素是指针（**p），然后再与int 结合，说明该指针所指向的元素是整型数据
int p[3] ； //首先从 p 处开始，先与 [] 结合,说明 p 是一个数组，然后与int 结合，说明数组里的元素是整型的，所以 p 是一个由整型数据组成的数组
int *p[3]； //首先从 p 处开始,先与 [] 结合，因为其优先级比 * 高；所以 p 是一个数组，然后再与 * 结合，说明数组里的元素是指针类型，然后再与int 结合，说明指针所指向的内容的类型是整型的，所以 p 是一个由返回整型数据的指针所组成的数组

文章到这就结束了，希望对你有帮助，觉得文章不错就点个赞吧。

文章有什么问题可以留言，感谢支持！！

原网站

版权声明
本文为[山里有神明]所创，转载请带上原文链接，感谢
https://fengye.blog.csdn.net/article/details/123615761