✨✨欢迎大家来到Celia的博客✨✨
🎉🎉创作不易,请点赞关注,多多支持哦🎉🎉
所属专栏:C语言
目录
一、内存和地址
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<stdio.h>
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<stdio.h>
int main()
{
int n = 0x55667788;//16进制数字
int* p = &n;
*p = 0;
printf("%d", n);
return 0;
}
这里的代码成功将变量n的值变成0,我们再来看下面的代码。
#include<stdio.h>
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<stdio.h>
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<stdio.h>
int main()
{
const int n = 10;
n = 5;//err,这里会报错
return 0;
}
const可以通过修饰变量,来让变量的值不可被修改,我们试一下用指针来操作。
#include<stdio.h>
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<stdio.h>
int main()
{
const int n = 10;
const int* p = &n;//左边
int const* p1 = &n;//左边
int* const p2 = &n;//右边
return 0;
}
五、指针运算
5.1 指针+-整数
指针加减整数可以理解为对指针的前后移动,举一个例子:
#include<stdio.h>
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<stdio.h>
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<stdio.h>
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<stdio.h>
int main()
{
int* p;//未初始化,默认为随机值
*p = 23;//err,在这里会报错
return 0;
}
2.指针越界访问
#include<stdio.h>
int main()
{
int arr[] = { 1,2,3,4,5 };
int* p = &arr[5];//越界访问
*p = 10;
return 0;
}
3.指针指向的空间的释放
我们知道,在自定义函数结束时,函数中的形参所占用的内存空间会被释放,如果一个函数的返回值是指针,返回了一个形参变量的地址,那么这个地址在返回的时候确实是返回到了主函数,但是在返回后这个地址所在的内存空间已经被释放,再次使用它可能会有危险。
#include<stdio.h>
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<stdio.h>
#include<assert.h>
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;
}
这里的报错指出了错误原因和错误出现的行数。