目录
一、内存和地址
1.内存
我们知道计算上CPU (中央处理器)在处理数据的时候,需要的数据是在内存中读取的,处理后的数据也会放回内存中,那我们买电脑的时候,电脑上内存是8GB/16GB/32GB等,那这些内存空间如何高效的管理呢?
其实也是把内存划分为一个个的内存单元,每个内存单元的大小取1个字节。 计算机中常见的单位(补充)∶
一个比特位可以存储一个2进制的位1或者0
1byte = 8bit 1KB = 1024byte 1MB = 1024KB 1GB = 1024MB 1TB = 1024GB 1PB = 1024TB
每个内存单元内可以放8个比特位 每个内存单元都有一个编号,CPU通过这些编号可以快速找到一个内存空间。我们称内存单元的变化为地址。C语言中给地址起了新的名字——指针。
2.理解编址
首先,必须理解,计算机内是有很多硬件单元的,而硬件单元是要互相协同工作的。所谓的协同,至少相互之间要能够进行数据传递。
但是硬件与硬件之间是互相独立的,那么如何通信呢?答案很简单,用"线"连起来。
而CPU和内存之间也是有大量的数据交互的,所以,两者必须也用线连起来。
不过,我们今天关心一组线,叫做地址总线。
我们句以简单理解,32位机器有32根地址总线,每根线只有两态,表示0,1【电脉冲有无】,那么一根线,就能表示2种含义,2根线就能表示4种含义,依次类推。32根地址线,就能表示2^32种含义,每一种含义都代表一个地址。
地址信息被下达给内存,在内存上,就可以找到该地址对应的数据,将数据在通过数据总线传入CPU内寄存器。
二、指针变量和地址
1.取地址符(&)
在C语言中,创建变量相当于在向内存申请空间。
#include <stdio.h>
int main()
{
int a = 10;
&a;//取出a的地址
printf("%p\n", &a);
return 0;
}
如图所示,打印结果为:006FFD70
&a取出的是int a 所占四个字节中地址最小的字节地址。因为四个字节是连续的,所以我们只要知道第一个字节便可。
2.指针变量和解引用操作符(*)
(1)指针变量
我们通过取地址操作符(&)拿到的地址是一个数值,比如:Ox006FFD70,这个数值也是需要存储起来,方便后期再使用的,所以我们把它存放在指针变量中。
#include <stdio.h>
int main()
{
int a = 10;
int* pa = &a;//取出a的地址并存储到指针变量pa中
return 0;
}
指针变量也是一种变量,这种变量就是用来存放地址的,存放在指针变量中的值都会理解为地址。
(2)如何拆解指针类型
int a = 10;
int * pa = &a;
我们看到pa的类型是int*
理解:*说明pa是指针变量,int说明pa指向的是int类型的对象。
(3)解引用操作符
C语言中,我们只要拿到了地址(指针),就可以通过地址(指针)找到地址(指针)指向的对象,这里必须学习一个操作符叫解引用操作符(*)。
#include<stdio.h>
int main()
{
int a = 100;
int* pa = &a;
*pa = 0;
return 0;
}
上面代码就使用了解引用操作符,*pa的意思就是通过pa中存放的地址,找到指向的空间,*pa其实就是a变量了;所以*pa=0,这个操作符是把a改成了0.
3.指针变量的大小
前面的内容我们了解到,
32位机器假设有32根地址总线,每根地址线出来的电信号转换成数字信号后是1或者0,那我们把32根地址线产生的2进制序列当做一个地址,那么一个地址就是32个bit位,需要4个字节才能存储。如果指针变量是用来存放地址的,那么指针变的大小就得是4个字节的空间才可以。
同理64位机器,假设有64根地址线,一个地址就是64个二进制位组成的二进制序列,存储起来就需要8个字节的空间,指针变的大小就是8个字节。
#include <stdio.h>
//指针变量的⼤⼩取决于地址的⼤⼩
//32位平台下地址是32个bit位(即4个字节)
//64位平台下地址是64个bit位(即8个字节)
int main()
{
printf("%zd\n", sizeof(char *));
printf("%zd\n", sizeof(short *));
printf("%zd\n", sizeof(int *));
printf("%zd\n", sizeof(double *));
return 0;
}
总结:
1、32位平台下地址是32个bit位,指针变量大小是4个字节. 2、64位平台下地址是64个bit位,指针变量大小是8个字节
3、注意指针变量的大小和类型是无关的,只要指针类型的变量,在相同的平台下,大小都是相同的。
三、指针变量类型的意义
1.解引用
//代码1
#include <stdio.h>
int main()
{
int n = 0x11223344;
int *pi = &n;
*pi = 0;
return 0;
}
//代码2
#include <stdio.h>
int main()
{
int n = 0x11223344;
char *pc = (char *)&n;
*pc = 0;
return 0;
}
通过调试我们可以看到,代码1会将n的4个字节全部改为0,但是代码2只是将n的第一个字节改为0。
结论:指针的类型决定了,对指针解引用的时候有多大的权限(一次能操作几个字节)。
比如: char*的指针解引用就只能访问一个字节,而int*的指针的解引用就能访问四个字节。
2.指针+-整数
#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*类型的指针变量+1跳过1个字节,int*类型的指针变量+1跳过了4个字节这就是指针变量的类型差异带来的变化。
结论:指针的类型决定了指针向前或者向后走一步有多大(距离)。
3.void*指针
在指针类型中有一种特殊的类型是 void* 类型的,可以理解为无具体类型的指针(或者叫泛型指针),这种类型的指针可以用来接受任意类型地址。但是也有局限性,void* 类型的指针不能直接进行指针的+-整数和解引用的运算。
#include <stdio.h>
int main()
{
int a = 10;
int* pa = &a;
char* pc = &a;
return 0;
}
在上面的代码中,将一个int类型的变量的地址赋值给一个char*类型的指针变量。编译器给出了一个警告(如下图),是因为类型不兼容。而使用void*类型就不会有这样的问题。
#include<stdio.h>
int main()
{
int a = 10;
void* pa = &a;
void* pc = &a;
*pa = 10;
*pc = 0;
return 0;
}
void*虽然可以接受不同类型的地址,但无法直接进行指针运算。通常使用于函数的参数部分,用来接受不同类型的地址,实现范编程的效果。
四、const修饰指针
1.const修饰变量
变量是可以修改的,如果把变量的地址交给一个指针变量,通过指针变量的也可以修改这个变量。但是如果我们希望一个变量加上一些限制,不能被修改,这就是const的作用。
#include<stdio.h>
int main()
{
int m = 0;
m = 20;//m是变量
const int n = 0;
n = 20;//n本质是变量,但不可以改变,可以称为常变量
printf("%d %d", m, n);
return 0;
}
上述代码中n是不能被修改的,其实n本质是变量,只不过被const修饰后,在语法上加了限制,只要我们在代码中对n就行修改,就不符合语法规则,就报错,致使没法直接修改n。
但是我们可以利用指针直接访问n的地址,就可以修改n的值了。但是这样会打破语法规则。
#include<stdio.h>
int main()
{
const int n = 0;
printf("n=%d\n", n);
int* p = &n;
*p = 20;
printf("n=%d\n", n);
return 0;
}
结论:
1.p里面存放的是a的地址
2.p是变量有自己的地址
3.*p是p指向的空间
2.const修饰指针变量
#include <stdio.h>
//代码1
void test1()
{
int n = 10;
int m = 20;
int* p = &n;
*p = 20;//ok?
p = &m; //ok?
}
void test2()
{
//代码2
int n = 10;
int m = 20;
const int* p = &n;
*p = 20;//ok?
p = &m; //ok?
}
void test3()
{
int n = 10;
int m = 20;
int* const p = &n;
*p = 20; //ok?
p = &m; //ok?
}
void test4()
{
int n = 10;
int m = 20;
int const* const p = &n;
*p = 20; //ok?
p = &m; //ok?
}
int main()
{
//测试⽆const修饰的情况
test1();
//测试const放在*的左边情况
test2();
//测试const放在*的右边情况
test3();
//测试*的左右两边都有const
test4();
return 0;
}
结论:
1. int const *p
限制的是*p,不能通过p来修改p指向的空间的内容。但是p自身不受限制。
2. int * const p
限制的是p,p变量不能被修改,不能指向其他地址,但*p不被限制,可以通过p来修改p指向的对象的内容
3. const int * const p
p和*p都限制
4. const如果放在*的左边,修饰的是指针指向的内容,保证指针指向的内容不能通过指针来改变。但是指针变量本身的内容可变。
5. const如果放在*的右边,修饰的是指针变量本身,保证了指针变量的内容不能修改,但是指针指向的内容,可以通过指针改变。