1. 指针的引入
1.1 内存
计算机上CPU(中央处理器)在处理数据的时候,需要的数据是在内存中读取的,处理后的数据也会放回内存中。我们知道CPU处理数据的速度是非常快的,那读取的速度必然有过之而无不及,那么数据如此之多,读取数据时是如何做到快、准、狠的呢?
计算机中内存被划分为一个个的内存单元,每个内存单元的大小为1个字节。每个内存单元也都有一个编号,有了这个内存单元的编号,CPU就可以快速找到一个内存空间。在计算机中我们把内存单元的编号称为地址。C语言中给地址有新的名字——指针。所以我们可以理解为:内存单元的编号==地址==指针。
补充:
一个比特位可以存储一个2进制的1或0。
计算机常见的表示内存的单位:
bit - 比特位
Byte - 字节
KB
MB
GB
TB
PB
这些单位的换算如下:
1Byte = 8bit
1KB = 1024Byte
1MB = 1024KB
1GB = 1024MB
1TB = 1024GB
1PB = 1024TB
1.2 编址
都知道CPU读取数据时是根据地址编号来读取的,所以,有地址编号才可以被读取。
给内存单元分配地址编号,以供CPU读取数据的过程就是编址。
1.3 地址总线
我们可以简单理解,32位机器有32根地址总线,每根线只有两态,表示0、1(电脉冲有无),那么一根线,就能表示2种含义,两根线就能表示2^2种含义,以此类推,32根地址线,就能表示2^32种含义,每一种含义都代表一个地址。
地址信息被下达给内存,在内存上,就可以找到该地址对应的数据,将数据再通过数据总线传入CPU内寄存器。
2. 指针变量和地址
2.1 取地址操作符(&)
首先我们要知道,在C语言中创建变量其实就是向内存申请空间,比如:
#include<stdio.h>
int main(){
int i = 2;
return 0;
}
上述的代码就是创建了整型变量i
,内存中申请4个字节,每个字节都有地址,用于存放整数2。那我们要是想得到变量i的地址应该怎么做呢?
这个时候就需要用到取地址符——&
,&i
取出的是i所占字节中地址较小的字节的地址。
虽然整形变量占用4个字节,但是我们只要知道了第一个字节地址,就可以顺藤摸瓜的访问到其他3个字节的数据。
2.2 指针变量
通过取地址操作符(&)取到的地址是一个数值,这个数值有时也需要存储,以供后续使用,此时就需要用到指针变量了。代码如下:
#include<stdio.h>
int main(){
int i = 2;
int * pi = &i;//取出i的地址并存储到指针变量pi中
return 0;
}
指针变量是专门存放地址的,指针变量所存储的值都会被系统理解为地址。
由上述代码可知,指针变量类型表示为int *
,其中,*
是在说明pi
是指针变量,而int
是在说明pi
指向的是整型类型。
2.3 解引用操作符(*)
当我们拿到的地址(指针)时,我们可以通过解引用操作符(*)来找到地址(指针)指向的对象。代码如下:
#include<stdio.h>
int main(){
int i = 2;
int * pi = &i;
*pi = 1;//通过pi来修改i的值
return 0;
}
上方第五行代码中用了解引用操作符( * ),表达式(*pi = 1
)所表示的意思是:将值 1 赋给pi
指向的内存单元。
2.4 指针变量的大小
前面我们讲到:32位机器假设有32根地址总线,每根地址线出来的电信号转换成数字信号后是1或者0,那我们把32根地址线产生的2进制序列当做⼀个地址,那么⼀个地址就是32个bit位,需要4个字节才能存储。同理,64位机器,假设有64根地址线,一个地址就是64个二进制组成的二进制序列,存储起来就需要8个字节的空间,指针变量的大小就是8个字节。
所以:
- 32位平台下地址是32个bit位,指针变量大小是4个字节
- 64位平台下地址是64个bit位,指针变量大小是8个字节
- 注意指针变量的大小和类型是无关的,只要指针类型的变量,在相同的平台下,大小都是相同的。
3. 指针变量类型的意义
指针变量的大小既然与类型无关,那又为什么要有各种各样的指针类型呢?
接下来我会从多个方面为各位解答:
3.1 指针的解引用
代码示例:
//代码1
#include<stdio.h>
int main(){
int i = 0x11223344;
int *pi = &i;
*pi = 0;
return 0;
}
//代码2
#include<stdio.h>
int main(){
int i = 0x11223344;
char *pi = (char *)&i;
*pi = 0;
return 0;
}
调试时,我们可以观察,代码1会将i的4个字节全部改为0,但是代码2只是将i的第一个字节改为0。
所以,指针的类型决定了指针解引用时的权限(一次能操作几个字节)。正如上方所示:char *
的指针解引用就只能访问1个字节,而int *
的指针解引用就能访问4个字节。
3.2 指针±整数
代码示例:
#include<stdio.h>
int main(){
int i = 0;
char *pc = (char*)&i;
int *pi = &i;
printf("%p\n", &i);
printf("%p\n", pc);
printf("%p\n", pc+1);
printf("%p\n", pi);
printf("%p\n", pi+1);
return 0;
}
运行结果:
从运行结果可以看出,char *
类型的指针变量+1只跳过了1个字节,int *
类型的指针变量+1跳过了4个字节。
所以,指针+1,其实是跳过了1个指针指向的元素。指针的类型决定了指针向前或者向后走一步有多大距离。
3.3 void* 指针
void *
类型是指针类型中的一种特殊类型,可以理解为无具体类型的指针(或者叫泛型指针),这种类型的指针可以用来接收任意类型地址。
void *
指针的局限性: void * 类型的指针不能直接进行指针的±整数和解引用的运算。
使用void *
指针接收地址的代码:
#include<stdio.h>
int main(){
int a = 10;
void *pa = &a;
void *pc = &a;
*pa = 10;
*pc = 0;
return 0;
}
运行警告:
这里我们可以看到,void *
类型的指针可以接收不同类型的地址,但是无法直接进行指针运算。
void *
的用途:
void *
类型的指针是使用在函数参数的部分,用来接受不同类型数据的地址,这样的设计可以实现泛型编程的效果。从而可以使用一个函数来处理多种类型的数据。
4. const 修饰指针
4.1 const 修饰变量
const 的作用是给变量加上限制,使其不可以被修改。代码如下:
#include<stdio.h>
int main(){
int n = 0;
n = 10;// n是不能被修改的
const int m = 0;
m = 20;// m是不能被修改的
return 0;
}
上述代码中m不可以被修改,直接加了const,在语法上对这个变量形成了限制,无法直接修改,但是可以间接修改。
如果我们绕过m,使用m的地址,就可以修改m了(这样做是在打破语法规则)。代码如下:
#include<stdio.h>
int main(){
const int m = 0;
printf("m = %d",m);
int *p = &m;
*p = 10;
printf("m = %d",m);
return 0;
}
输出结果:
我们可以看到,如果拿到m的地址,是可以修改m的值的,这样就打破了const的限制,修饰前可以改,修饰后也可以改,这是不合理的,所以应该让取到m的地址也不能修改m,应该怎么做呢?
4.2 const 修饰指针变量
const 修饰指针变量,既能放在 * 的左边,也能放在 * 的右边,表达的含义各有不同。
代码:
#include <stdio.h>
//代码1 - 测试⽆const修饰的情况
void test1()
{
int n = 10;
int m = 20;
int *p = &n;
*p = 20;//ok?
p = &m; //ok?
}
//代码2 - 测试const放在*的左边情况
void test2()
{
int n = 10;
int m = 20;
const int* p = &n;
*p = 20;//ok?
p = &m; //ok?
}
//代码3 - 测试const放在*的右边情况
void test3()
{
int n = 10;
int m = 20;
int * const p = &n;
*p = 20; //ok?
p = &m; //ok?
}
//代码4 - 测试*的左右两边都有const
void test4()
{
int n = 10;
int m = 20;
const int * const p = &n;
*p = 20; //ok?
p = &m; //ok?
}
int main()
{
//测试⽆const修饰的情况
test1();
//测试const放在*的左边情况
test2();
//测试const放在*的右边情况
test3();
//测试*的左右两边都有const
test4();
return 0;
}
根据报错显示,我们可以得出:
- const放在 * 左边,修饰的是指针指向的内容,指针指向的内容不能通过指针来改变。而指针变量本身的内容可以改变。
- const放在 * 右边,修饰的是指针变量本身,指针变量的内容不能改变,而指针指向的内容可以改变。
5. 指针运算
指针的基本运算有以下三种:
- 指针 ± 整数
- 指针 - 指针
- 指针的关系运算
5.1 指针±整数
我们知道数组在内存中是连续存放的,知道第一个元素的地址,顺藤摸瓜就能找到后面的所有元素。
int arr[10] = {1,2,3,4,5,6,7,8,9,10 };
代码:
#include<stdio.h>
int main(){
int arr[10] = {1,2,3,4,5,6,7,8,9,10};
int *p = &arr[0];
int i =0;
int sz = sizeof(arr)/sizeof(arr[0]);
for(i = 0;i < sz;i ++){
printf("%d",*(p+i));
}
return 0;
}
5.2 指针 - 指针
代码:
#include<stdio.h>
int my_strlen(char *s){
char * p = s;
while(*p != '\0')
p++;
return p - s;
}
int main(){
printf("%d\n",my_strlen("abc"));
return 0;
}
5.3 指针关系运算
代码:
#include<stdio.h>
int main(){
int arr[10] = {1,2,3,4,5,6,7,8,9,10};
int *p = &arr[0];
int sz = sizeof(arr)/sizeof(arr[0]);
while(p < arr + sz){
printf("%d ",*p);
p++;
}
return 0;
}
6. 野指针
指向已释放或不再有效的内存区域的指针就是野指针。
6.1 野指针成因
6.1.1 指针未初始化
例:
#include<stdio.h>
int main(){
int *p;// 局部变量指针未初始化,默认为随机值
*p = 10;
return 0;
}
6.1.2 指针越界访问
例:
#include<stdio.h>
int main(){
int arr[10] = {0};
int *p = &arr[0];
int i = 0;
for(i=0; i<=11; i++)
{
//当指针指向的范围超出数组arr的范围时, p就是野指针
*(p++) = i;
}
return 0;
}
6.1.3 指针指向的空间释放
例:
#include <stdio.h>
int *test()
{
int n = 100;
return &n;
}
int main(){
int *p = test();
printf("%d\n",*p);
return 0;
}
6.2 野指针的规避
6.2.1 指针要初始化
我们在创建指针变量时,如果知道其应该指向的地址就直接赋值地址,如果不知道应该指向哪里,就给指针赋值NULL。这样可以避免指针指向不确定的内存地址。
NULL是C语言中定义的一个标识符常量,值是0,0也可以是地址,这个地址是无法使用的,读写该地址时系统会报错。
6.2.2 防止指针越界
一个程序向内存申请了哪些空间,通过指针也只能访问哪些空间,不能越界访问。超出了就是越界访问。
6.2.3 避免返回局部变量的地址
如上方第三个代码例子,函数调用完之后,局部变量的空间已经还给系统,所以算是未定义行为。
注:
- 指针变量不再使用时,要及时置NULL。
- 指针使用之前要检查有效性(是否为NULL)。
7. assert 断言
assert.h
头文件定义了宏assert()
,用于在运行时确保程序符合指定条件,若不符合,就报错终止运行。这个宏称为“断言”。
assert(p != NULL);
上方代码就是对这个宏的应用,当运行到这儿的时候,会判断变量p 是否等于NULL。若不等于,则继续运行;若等于,则报错终止运行。
运行原理:
assert()
宏接受⼀个表达式作为参数。如果该表达式为真(返回值非零), assert()
不会产生任何作用,程序继续运行。如果该表达式为假(返回值为零),assert()
就会报错,在标准错误流 stderr
中写入⼀条错误信息,显示没有通过的表达式,以及包含这个表达式的文件名和行号。
如果确定程序没有问题,不需要再做断言,就在#include<assert.h>
语句的前面,定义了一个宏NDEBUG
。如下方代码:
#define NDEBUG
#include<assert,h>
使用assert()的好处:
- 能自动标识文件和出问题的行号。
- 无需更改代码就能开启或关闭assert。
缺点:
- 增加了程序运行时间。