【C语言入门】指针详解（1）

 ✨✨欢迎大家来到Celia的博客✨✨

🎉🎉创作不易，请点赞关注，多多支持哦🎉🎉

所属专栏：C语言

个人主页：Celia's blog~

目录

​编辑

一、内存和地址

1.1内存

1.2地址

二、指针变量和地址

2.1 定义指针变量

 2.2 指针变量的初始化和赋值

2.3 解引用操作符（*）

2.4 指针变量的大小

 三、指针变量类型的意义

3.1 指针的解引用

 3.2 指针+-整数

3.3 void*指针

四、const修饰指针

4.1 const修饰变量

4.2 const修饰指针变量

五、指针运算

5.1 指针+-整数

5.2 指针-指针

5.3 指针的关系运算

 六、野指针

6.1 野指针的成因

6.2 如何避免野指针

6.2.1 指针初始化

6.2.2 避免越界访问

6.3.3 当指针不再使用时，及时把指针赋值为NULL

七、assert断言

---

一、内存和地址

1.1内存

  我们在购买电脑的时候，常常会看见电脑内存为8GB/16GB/32GB等，这些就是计算机内存空间的大小。为了方便管理，计算机会将这些内存空间划分为一个个的内存单元，每个内存单元为1个字节。

常见的单位：

• bit  --  比特位  (一个比特位可以存储一个二进制的0或者1）
• byte  --  字节  --  1 byte = 8 bit
• KB  --  1 kb = 1024 byte
• MB  --  1MB = 1024KB 
• GB  --  1GB = 1024 MB
• TB  --  1 TB = 1024 GB
• PB  --  1 PB = 1024 TB

1.2地址

  为了准确的找到每一个内存单元，计算机将每一个内存单元都赋予了一个地址（在硬件层面实现），这样一来，就可以通过地址来精准的找到每一个内存单元了。（就像房间和门牌号一样）

顺便一提，计算机内有很多的硬件单元，这些单元之间通过“线”互相连接，能够实现协同工作，其中的一组“线”叫做地址总线。在x86（32位）环境下，有32根地址总线，每一根线都可以表示0或1（有无电脉冲），这样就有2^32种可能性，每一种都代表一个地址。同理，64位环境下的地址就有2^64种可能性，每一种都代表一个地址。

二、指针变量和地址

2.1 定义指针变量

  我们知道，数字5，也就是整型数据可以用int型变量来储存，浮点型数据可以用float和double型变量来储存……那么对于地址来说，也有一种专门来存储地址的变量，我们把这种变量叫做指针变量。

int a;//创建整型变量a，其中存储的是整型
int *b;//创建整型指针变量b，其中存储的是整型数据的地址

我们可以这样理解：*代表a是一个指针变量，int代表这个指针变量所指向的数据类型是一个整型（int）类型的对象。

char *a;//字符型指针变量
float *b;//单精度浮点型指针变量
double *c;//双精度浮点型指针变量

 2.2 指针变量的初始化和赋值

    既然指针变量内存储的是地址，那么我们只要把地址存入其中就可以了，那么问题来了，如何取出变量的地址呢？ 我们可以利用取地址操作符 & 取出a的地址。

int a = 10;//创建一个整型变量a
int *b = &a; //把a的地址赋值给整型指针变量b

2.3 解引用操作符（*）

   既然我们将地址存入指针变量中，那么就一定会去使用它，就像通过门牌号找到房间里的人一样，我们也可以通过地址来找到相应变量内存储的值。

int a = 10;
int *b = &a;//这里的*是指b是一个指针变量。
int c = *b;//这里的*是解引用操作符，取出了b中存储的地址中的值（a的值），赋值给c。

 之所以要通过指针来进行操作，而不是直接对变量进行赋值，好处之一是多了一种操作途径，其二是可以让后期的很多代码变得更加灵活。

2.4 指针变量的大小

  之前已经提到过，不同的环境（32/64位）中地址总线的数量不同，32位中的地址有2^32种可能性，64位中的地址有2^64种可能性。拿32位环境举例，这里的每个地址就需要32个bit位来表示，每个bit位代表0或1两种可能性，共有2^32种可能性，所以在这种环境下的地址大小为4个字节，同理，在64位环境下的地址大小为8个字节。

#include
int main()
{
	printf("%zd\n", sizeof(int*));
	printf("%zd\n", sizeof(short*));
	printf("%zd\n", sizeof(char*));
	printf("%zd\n", sizeof(float*));
	printf("%zd\n", sizeof(double*));
	return 0;
}

 需要注意：只要是指针变量，它的大小就为4/8个字节，视环境决定。

 三、指针变量类型的意义

  既然指针的大小和类型无关，那么为什么有那么多的指针类型呢？

3.1 指针的解引用

#include
int main()
{
	int n = 0x55667788;//16进制数字
	int* p = &n;
	*p = 0;
	printf("%d", n);
	return 0;
}

 这里的代码成功将变量n的值变成0，我们再来看下面的代码。

#include
int main()
{
	int n = 0x55667788;
	char* p = &n;
	*p = 0;
	printf("%d", n);
	return 0;
}

 这里的代码仅仅是在指针的类型上有所不同，为什么没有把n赋值为0呢？

结论：指针的类型决定了指针可以访问的权限（几个字节）。

• int*类型的指针在解引用时可以访问四个字节，把四个字节的所有bit位都赋值为0。
• char*类型的指针解引用时可以访问1个字节，把一个字节的所有bit位赋值为0。

 3.2 指针+-整数

观察下面的代码

#include
int main()
{
	int n = 10;
	char* p = &n;
	int* p1 = &n;
	printf("%p\n", p);//%p打印地址
	printf("%p\n", p+1);
	printf("%p\n", p1);
	printf("%p\n", p1+1);
	return 0;
}

 我们可以发现，int*类型的指针+1跳过了4个字节，char*类型的指针+1跳过了1个字节。

 结论：指针的类型决定了指针前后移动的距离。

3.3 void*指针

  除了上述类型的指针外，还有一种类型的指针：void*指针（泛型指针）。这种指针没有具体的类型，可以接受任何类型的地址，但是也有局限性：不能直接进行解引用和加减整数的运算。

四、const修饰指针

4.1 const修饰变量

#include
int main()
{
	const int n = 10;
	n = 5;//err，这里会报错
	return 0;
}

 const可以通过修饰变量，来让变量的值不可被修改，我们试一下用指针来操作。

#include
int main()
{
	const int n = 10;
	int* p = &n;
	*p = 5;//这里不会报错
	return 0;
}

这样就打破了语法规则，是不会报错的，但是我们又不想让n的值改变 ，那该怎么办呢？我们可以用const修饰指针变量来达到这样的效果。

4.2 const修饰指针变量

const int* p = &n;

 我们可以在最前面加上const，这样一来，就算用指针来操作n的值，也同样会报错，达到了不让n的值改变的目的。

实际上const修饰指针变量还有几种类型：

• const放在*的左边：修饰的是指针指向的内容，保证了指针指向的内容不会被改变。但是指针变量本身的内容可变。
• const放在*的右边：修饰的是指针本身，保证了指针变量的内容（储存的地址）不会被改变。但是指针指向的内容可变。

#include
int main()
{
	const int n = 10;
	const int* p = &n;//右边
	int const* p1 = &n;//右边
	int* constp2 = &n;//左边
	return 0;
}

五、指针运算

5.1 指针+-整数

  指针加减整数可以理解为对指针的前后移动，举一个例子：

#include
int main()
{
	int a[] = { 1,2,3,4,5 };
	int sz = sizeof(a) / sizeof(a[0]);
	int* p = &a[0];
	for (int i = 0; i < sz; i++)
	{
		printf("%d ", *(p + i));
	}
	return 0;
}

由于数组在内存中是连续存放的，所以当p得到了数组的首地址后，就可以顺着找到数组的所有元素。 

5.2 指针-指针

#include
int main()
{
	int a[] = { 1,2,3,4,5 };
	int sz = sizeof(a) / sizeof(a[0]);
	int* p = &a[0];
	int* p1 = &a[4];
	printf("%d ", p1 - p);
	return 0;
}

 指针-指针的运算结果是两个指针之间的元素个数（注意不是字节数）。

5.3 指针的关系运算

#include
int main()
{
	int a[] = { 1,2,3,4,5 };
	int sz = sizeof(a) / sizeof(a[0]);
	int* p = &a[0];
 
	while (p < a + sz)//a为数组的首元素地址，相当于&a[0]
	{
		printf("%d ", *p);
		p++;
	}
	return 0;
}

 指针也可以进行大小比较，这里是利用了数组元素在内存中连续存放的原理，遍历了整个数组。

 六、野指针

 野指针：访问一个已销毁或者访问受限的内存区域的指针。

6.1 野指针的成因

1. 指针未初始化

#include
int main()
{
	int* p;//未初始化，默认为随机值
	*p = 23;//err，在这里会报错
	return 0;
}

2.指针越界访问

#include
int main()
{
	int arr[] = { 1,2,3,4,5 };
	int* p = &arr[5];//越界访问
	*p = 10;
	return 0;
}

3.指针指向的空间的释放

  我们知道，在自定义函数结束时，函数中的形参所占用的内存空间会被释放，如果一个函数的返回值是指针，返回了一个形参变量的地址，那么这个地址在返回的时候确实是返回到了主函数，但是在返回后这个地址所在的内存空间已经被释放，再次使用它可能会有危险。

#include
int* find()
{
	int n = 20;
	return &n;//返回一个形参的地址
}
int main()
{
	int* p = find();//接收地址
	printf("%d", *p);
	return 0;
}

6.2 如何避免野指针

6.2.1 指针初始化

  如果明确知道地址的指向就直接赋值，如果实在无法确定指针的指向，可以赋值为NULL。

NULL是一个标识符常量，值是0，0也是一个地址，且这个地址无法使用。

int *p = NULL;

6.2.2 避免越界访问

  一个程序在内存中开辟了哪些空间，指针也就只访问哪些空间，避免越界访问。

6.3.3 当指针不再使用时，及时把指针赋值为NULL

 指针指向一块区域时，我们可以通过指针访问这些区域，当完成我们想进行的操作时，可以把指针赋值为NULL，避免在接下来的程序段出现不可预知的错误。

七、assert断言

  assert.h头文件中定义了宏assert（）。可以在程序运行时检查程序是否符合指定条件 ，如果符合，assert不会产生任何作用，程序会正常运行，如果不符合，会终止程序并且报错。

以下是一些举例：

int *p;
assert(p!=NULL);

#include
#include
int main()
{
	int arr[] = { 1,2,3,4,5 };
	int i;
	for (i = 0; i < 6; i++)
	{
		assert(i < 5);//断言
		printf("%d ", arr[i]);
	}
	return 0;
}

这里的报错指出了错误原因和错误出现的行数。