1.指针与内存的关系
1.1小案例
在讲内存和地址之前,我们想有个⽣活中的案例:
假设有⼀栋宿舍楼,把你放在楼⾥,楼上有100个房间,但是房间没有编号,你的⼀个朋友来找你玩,
如果想找到你,就得挨个房⼦去找,这样效率很低,但是我们如果根据楼层和楼层的房间的情况,给
每个房间编上号,如:
1.一楼:101,102,103……
2.二楼:201,202,203……
……
有了房间号,如果你的朋友得到房间号,就可以快速的找房间,找到你。
其实计算机存储与小案例的原理是一模一样的,我们知道计算机CPU(中央处理器)在处理数据的时候,是要向内存读取需要的数据的,处理之后也会放回内存中(大致关系如下图)。
那我们在买电脑的时候,电脑上的内存是8GB/16GB/32GB等,这些内存是怎样高效处理的呢?
其实也是把内存分为一个一个的内存单元,每个单元的大小为一个字节
补充
计算机最小单位为比特位(bit),一个比特位可以存储二进制的位0或1,一个字节(byte)能存放八个比特位(关系图如下)
其中每个内存单元就相当于一个学生宿舍,一个字节能放八个比特位,类似于一个八人的宿舍,其中的每一个学生就是一个比特位
每个内存单元都有一个内存编号(这个编号就相当于门牌号),有了这个"门牌号",CPU就能快速的找到一个内存空间,在生活中我们会把门牌号称为地址,当然,在计算机中我们也把内存单元的编号称为地址,C语言给地址起了个新名字: 指针
所以我们理解为内存编号 == 地址 == 指针
2.指针变量和地址
2.1 取地址操作符(&)
在C语言创建变量的本质是向内存申请空间
我们怎样才能拿到变量a的地址呢?(&a会取出a所占的4个字节中较小的字节的地址编号)
2.2 指针变量与地址
概念
那我们通过取地址操作符(&)拿到的地址是⼀个数值,⽐如:0x0012FF40,这个数值有时候也是需要
存储起来,⽅便后期再使⽤的,那我们把这样的地址值存放在哪⾥呢?
答案就是指针变量
比如:
#include<stdio.h>
int main()
{
int a = 10;
int* p = &a;//取出a的地址,并将其存放在指针变量p中
return 0;
}
指针变量也是一种变量,这种变量就是用来存放地址的,所以存放在指针变量里的值,都被理解为地址。
指针是地址,指针变量是存放地址的变量(我们口头上说的指针绝大多数都是指针变量)
创建
我们看到p的类型是int*,我们该如何理解指针的类型呢?
p是一个变量(指针变量),是一块空间,*号是在说明p是指针变量(如果没有*,那p就只是一个int类型的变量),int说明p所指向的对象是int类型的
那如果有⼀个char类型的变量ch,ch的地址,要放在什么类型的指针变量中呢?
char ch = 'a';
pc = &ch;//pc应该是什么类型呢
答案
char* pc = &ch;
解引用操作符
我们将地址保存了,未来是会使用的,那如何使用呢?
在现实⽣活中,我们使⽤地址要找到⼀个房间,在房间⾥可以拿去或者存放物品。
C语⾔中其实也是⼀样的,我们只要拿到了地址(指针),就可以通过地址(指针)找到地址(指针)
指向的对象,这⾥必须学习⼀个操作符叫解引⽤操作符(*)
代码如下:
#include <stdio.h> //1
int main() //2
{ //3
int a = 100; //4
int* pa = &a; //5
*pa = 0; //6
//7
printf("*pa = %d\n", *pa); //8
printf("a = %d ", a); //9
return 0; //10
} //11
上面的第六行就使用解引用操作符,*pa的意思就是通过pa存放的地址,找到pa所指向的内容。其实*pa就是变量a了;所以*pa = 0,这个操作符也把a改为0了。
这里的目的就是把a改成0的话,写成a = 0; 不就完了,为啥非要使用指针呢?
其实这里是把a的修改交给了pa来操作,这样对a的修改,就多了⼀种的途径,写代码就会更加灵活,
后期慢慢就能理解了。
指针变量的大小
32位机器假设有32根地址总线,每个地址线有两态(低电频和高电频;低电频为0,高电频为1),我们把32跟地址线产生的二进制序列当做一个地址,那么一个地址就有32个bit位,就需要4个字节才能存放;64位机器同理,所以在64位环境下指针变量的大小是8个字节
int main()
{
//指针变量的⼤⼩取决于地址的⼤⼩
//32位平台下地址是32个bit位(即4个字节)
//64位平台下地址是64个bit位(即8个字节)
printf("%d\n", sizeof(char *));
printf("%d\n", sizeof(short *));
printf("%d\n", sizeof(int *));
printf("%d\n", sizeof(long *));
printf("%d\n", sizeof(long long *));
printf("%d\n", sizeof(float *));
printf("%d\n", sizeof(double *));
return 0;
}
指针变量的大小和类型无关,只要是指针类型的变量,在同样的环境下,大小都是相同的。
3.指针变量的意义
指针变量的大小和类型无关,只要是指针变量,在同⼀个平台下,⼤⼩都是⼀样的,为什么还要有各种各样的指针类型呢?
其实指针类型是有特殊意义的,我们接下来继续学习。
3.1 指针的解引用
//代码一
int main()
{
int n = 0x11223344;
int* p = &n;
*p = 0;
return 0;
}
代码二
int main()
{
int n = 0x11223344;
char* p = (char*)&n;
*p = 0;
return 0;
}
我们进行调试看看这两个代码中内存的变化
调试我们可以看到,代码1会将n的4个字节全部改为0,但是代码2只是将n的第⼀个字节改为0。
结论
指针的类型决定了,对指针解引用的时候有多打的权限(一次能操作几个字节)。
⽐如:char* 的指针解引用就只能访问⼀个字节,而int* 的指针的解引用就能访问四个字节。
3.2指针加减整数
我们先看一段代码,重点看他们地址的变化。
int main()
{
int a = 100;
int* pa = &a;
char* pc = (char*)&a;
printf("&a = %p\n", &a);
printf("pa = %p\n", pa);
printf("pa+1 = %p\n", pa+1);
printf("pc = %p\n", pc);
printf("pc+1 = %p\n", pc+1);
return 0;
}
结果如下
我们可以看出int* 类型的指针加1跳过4个字节,而char*类型的指针加1跳过的是1个字节。
结论
指针类型决定了指针向前走或向后走一步能有多大。
3.3void*指针
在指针类型中void* 一种特殊的指针类型,可以理解为无具体类型的指针(也叫泛型指针)这种类型的指针可以接收任意类型的指针但它也有局限性,void*类型的指针不能进行解引用和加减整数的运算
例
int main()
{
int a = 0;
int* pa = &a;
char* pc = &a;
return 0;
}
在上面的代码中,我将一个int类型的变量的地址赋给char*类型的指针变量中。在我尝试运行的时候,编译器会发出一个警告(如下图),这是因为类型不兼容,但void*不会有这个问题
用void*类型的指针来接收地址:
int main()
{
int a = 0;
void* pa = &a;
void* pc = &a;
*pa = 10;
*pc = 0;
pc++;
return 0;
}
在VS中*pa = 10; *pc = 0; pc++;这三条指令会直接标红线(报错)。
运行结果肯定是不通过的
这里我们能看到,void*类型的指针能接收其他类型的地址,但不能直接对指针进行运算。
那void*类型的指针有什么用呢?
一般void*类型的指针是使用在函数参数的部分,用来接收不同类型的数据的地址,这样的设计可以实现泛型编程的效果,使得⼀个函数来处理多种类型的数据。
4.const修饰指针
4.1const修饰变量
变量是可以修改的,如果把变量的地址交给⼀个指针变量,我们也可以通过指针变量来修改这个变量。但是如果我们希望⼀个变量加上⼀些限制,不能被修改,怎么做呢?这就是const的作用。
int main()
{
int m = 0;
m = 100;//可以修改
const int n = 0;
n = 10;//经过const修饰后不可修改
return 0;
}
虽然上述的代码中n是无法被修改的,但其实n的本质还是变量,只是被const修饰过后有了常属性,也在语法上加了限制,只要我们对n进行了修改,就不符合语法,就会报错,使我们无法修改n的值。
但是,如果我们绕过n,去使用n的地址,就能去修改n的值了,虽然这样是在打破语法规则。
#include<stdio.h>
int main()
{
const int n = 0;
printf("n = %d\n", n);
int* pa = &n;
*pa = 100;
printf("n = %d\n", n);
return 0;
}
输出结果:
这里可以看到,n确实被修改了,但是让我们想想,我们为什么要用const修饰n,不就是因为不想n的值被修改吗,如果pa能通过n的地址来修改n,这样就打破了const所带来的语法规则,这很显然是不合理的,所以我们要让pa即使拿到了n的地址也不能修改n的值,这该怎么做呢?
4.2const修饰指针变量
我们可以看下面的代码并进行分析
void test0()
{
int m = 0;
int n = 0;
int* pa = &n;
*pa = 0;
pa = &m;
}
void test1()
{
int m = 0;
int n = 0;
int* const pa = &n;
*pa = 0;
pa = &m;
}
void test2()
{
int m = 0;
int n = 0;
int const* pa = &n;
*pa = 0;
pa = &m;
}
void test3()
{
int m = 0;
int n = 0;
int const * const pa = &n;
*pa = 0;
pa = &m;
}
int main()
{
test0();//指针变量没有const
test1();//*号右边有const
test2();//*号左边有const
test3();//*号左右都有const
return 0;
}
这时VS会自动标出错误
结论
当const修饰在*号的右边时,const限制的是指针变量本身,指针变量不能再指向其他变量的地址,但可以通过指针变量来改变指针变量本身指向的内容。
当const修饰在*号的左边时,const这次限制的是指针变量所指向的内容,不能通过指针变量来修改被指向的内容,但可以修改指针变量本身的值(也就是修改指针变量的指向)。
const修饰在*号的左右两侧时,这时指针变量既不能修改被指向的内容,也不能修改自身指向的对象。
5.指针运算
5.1 指针±整数
我们知道数组在内存中是连续存放的,所以我们如果知道了第一个元素的地址,就能顺藤摸瓜的找到后面的元素了
//指针+-整数
int main()
{
int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };
int* pa = &arr[0];
int sz = sizeof(arr) / sizeof(arr[0]);
for (int i = 0; i < sz; i++)
{
printf("%d ", *(pa + i));//这就是指针+-整数
}
return 0;
}
指针加减多少整数就能跳过多少个自身的类型所占的字节;
type * p; p + 1 ->跳过1*(sizeof(type));
p + n;->跳过n*(sizeof(type));
5.2指针-指针
模拟实现strlen(求字符串长度)
代码如下:
//指针-指针
int my_strlen(const char* pc)
{
char* tmp = pc;
while (*pc != '\0')
{
pc++;
}
return pc - tmp;//指针-指针
}
int main()
{
char ch[] = "abcdef";
int ret = my_strlen(ch);//数组名是首元素的地址
printf("%d\n", ret);
return 0;
}
指针-指针得到的是两个指针之间的元素个数(前提是两个指针指向的同一块空间)
5.3指针的关系运算
就是比较指针与指针(地址与地址)之间的大小
//指针的关系运算
int main()
{
int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };
int* pa = arr;//数组名是首元素地址
int i = 0;
int sz = sizeof(arr) / sizeof(arr[0]);
while (p < arr + sz) //指针的大小比较
{
printf("%d ", *p);
p++;
}
return 0;
}
6.野指针
概念:野指针是因为指针指向的位置是不可知的(随机的,不正确的,没有明确限制的)
6.1野指针的成因
1.指针未进行初始化
int main()
{
int* p;//指针未初始化
*p = 0;
return 0;
}
2.指针越界访问
int main()
{
int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };
int* pa = arr;
int sz = sizeof(arr) / sizeof(arr[0]);
for (int i = 0; i <= 11; i++)
{
*(pa++) = i;//当指针当指针指向的范围超出数组arr的范围时,pa就是野指针
}
return 0;
}
而且在VS中运行会报错
3.指针指向的空间释放
int* test()
{
int a = 10;
return &a;//局部变量出了函数,内存空间就销毁了。
}
int main()
{
int* pa = test();//指针指向的地址已经还给了操作系统
return 0;
}
相当于你租了一天的酒店房间,这一天这个酒店房间的使用权归你,但过了这一天,这个房间的使用权就还给了酒店,你可以看到这个房间,但已经使用不了了。
6.2如何规避野指针
1.指针初始化
如果你在设立指针的时候明确知道指针该指向哪里,就初始化一个明确的地址,
如果目前还不知道该指向哪里,就给指针赋值一个NULL。
NULL是C语言中定义的一个标识符常量,值为0,0也是地址,但是这个地址是给操作系统用的,我们用户是无法使用的
//NULL的定义
#ifndef NULL
#ifdef __cplusplus
#define NULL 0
#else
#define NULL ((void *)0)
初始化如下
#include<stdio.h>
int main()
{
int n = 10;
int* pn = &n;
int* pa = NULL;
return 0;
}
2.小心指针越界
当你向内存申请了哪些空间,那么就限定你的指针只能访问哪些空间,不要超出访问范围,超出了就是越界访问(野指针)
3.当指针变量不在使用时,及时的设置为NULL,在使用指针之前先检查有效性
当指针变量指向一块区域时,我们可以通过访问指针来访问该区域,在后期我们不再使用这个指针来访问空间的时候,我们就及时的设置为NULL。
因为约定俗成的⼀个规则就是:只要是NULL指针就不去访问,同时使⽤指针之前可以判断指针是否为NULL。
int main()
{
int arr[10] = { 1,2,3,4,5,67,7,8,9,10 };
int* p = &arr[0];
for (int i = 0; i < 10; i++)
{
*(p++) = i;
}
//此时p已经越界了,可以把p置为NULL
p = NULL;
//下次使⽤的时候,判断p不为NULL的时候再使⽤
//...
p = &arr[0];//重新让p获得地址
if (p != NULL) //判断
{
//...
}
return 0;
}
4避免返回局部变量的地址
就不要做野指针成因的第三个例子就可以了。
7.assert断言
在使用assert前要包含头文件<assert.h>,其中头文件就定义了宏assert(),用于在运行时确认程序符合指定条件,如果不符合,就直接或报错并终止运行
assert(p != NULL);
上面这个代码在程序运行到这一条时,会验证变量p是否等于NULL。如果确实不等于NULL,代码不会起任何作用,否者就会终止运行,并给出报错信息提示。
assert()是一个对程序员非常友好的代码,它不仅能自动标识文件错问题的行号,还有一种无需增加删减代码就能开启或关闭assert()的机制。在你明确代码没有错误可以轻松关闭assert断言,就在头文件#include <assert.h>语句的前一行,定义一个宏NDEBUG。
#define NDEBUG
#include<stdio.h>
如果程序又出现了问题,就可以注释掉#define NDEBUG指令,再次编译,这样就出现启动了assert()语句。
当然assert也不是完美的
它的缺点就是,因为有了额外的检查,会增加程序运行的时间。
般我们可以在Debug 中使用,在 Release版本中选择禁⽤assert 就行,在VS 这样的集成开发环境,在Release 版本中,直接就是优化掉了。这样在debug版本写有利于程序员排查问题,Release 版本不影响用户使用时程序的效率。
结语
感谢您能阅读完此片文章,如果有任何建议或纠正欢迎在评论区留言。如果您认为这篇文章对您有所收获,点一个小小的赞就是我创作的巨大动力,谢谢!