C语言学习 12(指针学习1)

一.内存和地址

1.内存
在讲内存和地址之前,我们想有个⽣活中的案例:
假设有⼀栋宿舍楼,把你放在楼⾥,楼上有100个房间,但是房间没有编号,你的⼀个朋友来找你玩,如果想找到你,就得挨个房⼦去找,这样效率很低,但是我们如果根据楼层和楼层的房间的情况,给每个房间编上号,如:

cs 复制代码
⼀楼:101,102,103...
⼆楼:201,202,203...
...

有了房间号,如果你的朋友得到房间号,就可以快速的找房间,找到你。


⽣活中,每个房间有了房间号,就能提⾼效率,能快速的找到房间。
如果把上⾯的例⼦对照到计算机中,⼜是怎么样呢?
我们知道计算机上CPU(中央处理器)在处理数据的时候,需要的数据是在内存中读取的,处理后的数据也会放回内存中,那我们买电脑的时候,电脑上内存是 8GB/16GB/32GB 等,那这些内存空间如何⾼效的管理呢?
其实也是把内存划分为⼀个个的内存单元,每个内存单元的⼤⼩取1个字节。
计算机中常⻅的单位(补充):
⼀个⽐特位可以存储⼀个2进制的位1或者0

cs 复制代码
bit - ⽐特位
Byte - 字节
KB
MB
GB
TB
PB
cs 复制代码
1Byte = 8bit
1KB = 1024Byte
1MB = 1024KB
1GB = 1024MB
1TB = 1024GB
1PB = 1024TB

其中,每个内存单元,相当于⼀个学⽣宿舍,⼀个字节空间⾥⾯能放8个⽐特位,就好⽐同学们住
的⼋⼈间,每个⼈是⼀个⽐特位。
每个内存单元也都有⼀个编号(这个编号就相当于宿舍房间的⻔牌号),有了这个内存单元的编
号,CPU就可以快速找到⼀个内存空间。
⽣活中我们把⻔牌号也叫地址,在计算机中我们把内存单元的编号也称为地址。C语⾔中给地址起
了新的名字叫:指针
所以我们可以理解为:内存单元的编号 == 地址 == 指针

实际电脑存储的时候,应该是下面的内存大,上面的内存小。 (由小内存向大内存存储)
2.如何理解内存的存储

CPU访问内存中的某个字节空间,必须知道这个字节空间在内存的什么位置,⽽因为内存中字节
很多,所以需要给内存进⾏编址(就如同宿舍很多,需要给宿舍编号⼀样)。
计算机中的编址,并不是把每个字节的地址记录下来,⽽是通过硬件设计完成的。
钢琴、吉他 上⾯没有写上"do、ri、mi、fa、so、la、xi"这样的信息,但演奏者照样能够准确找到每⼀个琴弦的每⼀个位置,这是为何?因为制造商已经在乐器硬件层⾯上设计好了,并且所有的演奏者都知道。本质是⼀种约定出来的共识!
硬件编址也是如此我们可以简单理解,32位机器有32根地址总线,每根线只有两态,表⽰0,1【电脉冲有⽆】,那么⼀根线,就能表⽰2种含义,2根线就能表⽰4种含义,依次类推。32根地址,就能表⽰2^32种含义,每⼀种含义都代表⼀个地址。
地址信息 被下达给内存,在内存上,就可以找到该地址对应的数据,将数据在通过数据总线传⼊
CPU内寄存器。
⾸先,必须理解,计算机内是有很多的硬件单元,⽽硬件单元是要互相协同⼯作的。所谓的协同,⾄少相互之间要能够进⾏数据传递。但是硬件与硬件之间是互相独⽴的,那么如何通信呢?答案很简单,⽤"线"连起来。⽽CPU和内存之间也是有⼤量的数据交互的,所以,两者必须也⽤线连起来。不过,我们今天关⼼⼀组线,叫做地址总线
二.指针变量和地址
1.取地址操作符(&)
理解了内存和地址的关系,我们再回到C语⾔,在C语⾔中创建变量其实就是向内存申请空间,⽐如:

⽐如,上述的代码就是创建了整型变量a,内存中申请4个字节,⽤于存放整数10,其中每个字节都有地址,上图中4个字节的地址分别是:

那我们如何能得到a的地址呢?
这⾥就得学习⼀个操作符(&)-取地址操作符

cs 复制代码
#include <stdio.h>
int main()
{
	int a = 10;
	&a;
	printf("%p\n", &a);
	return 0;
}
  • 每运行一次,存储的地址就会发生一次改变。

按照我画图的例⼦,会打印处理:006FFD70,&a取出的是a所占4个字节中地址较⼩的字节的地
址。


虽然整型变量占⽤4个字节,我们只要知道了第⼀个字节地址(内存的存储是连续的,在同一个变量下),顺藤摸⽠访问到4个字节的数据也是可⾏的。
2.指针变量
那我们通过取地址操作符(&)拿到的地址是⼀个数值,⽐如: 0x006FFD70 ,这个数值有时候也是需要存储起来,⽅便后期再使⽤的,那我们把这样的地址值存放在哪⾥呢?答案是: 指针变量中 。
比如:

cs 复制代码
#include <stdio.h>
int main()
{
	int a = 10;
	int* pa = &a; //取出a的地址,存入指针变量pa中。
	return 0;
}

指针变量也是⼀种变量,这种变量就是⽤来存放地址的,存放在指针变量中的值都会理解为地址(所以在输入的时候,就可以不用再加&)
3.如何拆解指针类型
我们看到pa的类型是 int* ,我们该如何理解指针的类型呢?

cs 复制代码
int a = 10;
int* pa = &a;

这⾥pa左边写的是 int* , * 是在说明pa是指针变量,⽽前⾯的 int 是在说明pa指向的是整型(int)
类型的对象。

那如果有⼀个char类型的变量ch,ch的地址,要放在什么类型的指针变量中呢?

cs 复制代码
char ch = 'A';
char* pc = &ch; 

4.解引用操作符(*)
我们将地址保存起来,未来是要使⽤的,那怎么使⽤呢?
在现实⽣活中,我们使⽤地址要找到⼀个房间,在房间⾥可以拿去或者存放物品。
C语⾔中其实也是⼀样的,我们只要拿到了地址(指针),就可以通过地址(指针)找到地址(指针)
指向的对象,这⾥必须学习⼀个操作符叫解引⽤操作符(*)

cs 复制代码
#include <stdio.h>
int main()
{
	int a = 10;
	int* pa = &a;
	*pa = 0;
	printf("%d", a);
	return 0;
}

打印结果:


上⾯代码中第5⾏就使⽤了解引⽤操作符, *pa 的意思就是通过pa中存放的地址,找到指向的空间,*pa其实就是a变量了 ;所以*pa = 0,这个操作符是把a改成了0.
有人肯定在想,这⾥如果⽬的就是把a改成0的话,写成 a = 0; 不就完了,为啥⾮要使⽤指针呢?
其实这⾥是把a的修改交给了pa来操作,这样对a的修改,就多了⼀种的途径,写代码就会更加灵活,后期慢慢就能理解了。
5.指针变量的大小
前⾯的内容我们了解到,32位(bit)机器 假设有32根地址总线,每根地址线出来的电信号转换成数字信号后是1或者0,那我们把32根地址线产⽣的2进制序列当做⼀个地址,那么⼀个地址就是32个bit位,需要4个字节才能存储。
如果指针变量是⽤来存放地址的,那么指针变量的⼤⼩就得是4个字节的空间才可以。
同理64位(bit)机器 ,假设有64根地址线,⼀个地址就是64个⼆进制位组成的⼆进制序列,存储起来就需要8个字节的空间,指针变量的⼤⼩就是8个字节。

cs 复制代码
#include <stdio.h>
//指针变量的⼤⼩取决于地址的⼤⼩
//32位平台下地址是32个bit位(即4个字节)
//64位平台下地址是64个bit位(即8个字节)
int main()
{
	printf("%zd\n", sizeof(int*));
	printf("%zd\n", sizeof(short*));
	printf("%zd\n", sizeof(double*));
	printf("%zd\n", sizeof(char*));
	printf("%zd\n", sizeof(float*));
	return 0;
}

x64环境(16进制)打印:


x86环境(8进制)打印:

结论:

  • 32位平台下地址是32个bit位,指针变量⼤⼩是4个字节
  • 64位平台下地址是64个bit位,指针变量⼤⼩是8个字节

注意:指针变量的⼤⼩和类型是⽆关的,只要指针类型的变量,在相同的平台下,⼤⼩都是相同的。
三.指针变量类型的意义
指针变量的⼤⼩和类型⽆关,只要是指针变量,在同⼀个平台下,⼤⼩都是⼀样的,为什么还要有各种各样的指针类型呢?
其实指针类型是有特殊意义的,我们接下来继续学习。
1.指针的解引用
对⽐,下⾯2段代码,主要在调试时观察内存的变化。
代码一:

cs 复制代码
#include <stdio.h>
int main()
{
	int a = 0x11223344;
	int* pa = &a;
	*pa = 0;
	return 0;
}

第一段代码的内存改变的情况:


代码二:

cs 复制代码
#include <stdio.h>
int main()
{
	int a = 0x11223344;
	char* pa = &a;
	*pa = 0;
	return 0;
}

第二段代码内存改变情况:


调试我们可以看到,代码1会将n的4个字节全部改为0 ,但是代码2只是将n的第⼀个字节改为0
结论:指针的类型决定了,对指针解引⽤的时候有多⼤的权限(⼀次能操作⼏个字节)。
⽐如: char* 的指针解引⽤就只能访问⼀个字节,⽽ int* 的指针的解引⽤就能访问四个字节。
2.指针+-整数
先看⼀段代码,调试观察地址的变化。

cs 复制代码
#include <stdio.h>
int main()
{
	int a = 10;
	int* pa = &a;
	char* pc = &a;
	printf("%p\n", &a);
	printf("%p\n", pa);
	printf("%p\n", pc);
	printf("%p\n", pa + 1);
	printf("%p\n", pc + 1);
	return 0;
}

打印结果:


我们可以看出,char* 类型的指针变量+1跳过1个字节, int* 类型的指针变量+1跳过了4个字节。
这就是指针变量的类型差异带来的变化。指针+1,其实跳过1个指针指向的 元素 。指针可以+1,那也可以-1。
提醒:上面那个代码编译时会报警告,因为a是int类型,最好不要用其它指针类型(char*等)。
结论:指针的类型决定了指针向前或者向后⾛⼀步有多⼤(距离,跳过多少个元素)。
3.void*指针
在指针类型中有⼀种特殊的类型是 void * 类型 的,可以理解为**⽆具体类型的指针**(或者叫泛型指
针),这种类型的指针可以⽤来接受任意类型地址。但是也有局限性, void* 类型的指针不能直接进⾏指针的+-整数和解引⽤的运算。
举例:

cs 复制代码
#include <stdio.h>
int main()
{
	int a = 10;
	int* pa = &a;
	char* pc = &a;
	return 0;
}

在上⾯的代码中,将⼀个int类型的变量的地址赋值给⼀个char*类型的指针变量。编译器给出了⼀个警告(如下图),是因为类型不兼容。⽽使⽤void*类型就不会有这样的问题。

使⽤void*类型的指针接收地址:

cs 复制代码
#include <stdio.h>
int main()
{
	int a = 10;
	void* pa = &a;
	void* pc = &a;
	*pa = 0;
	*pc = 0;
	return 0;
}

VS2022编译结果:


这⾥我们可以看到, void* 类型的指针可以接收不同类型的地址,但是⽆法直接进⾏指针运算。
那么 void* 类型的指针到底有什么⽤呢?
⼀般 void* 类型的指针是使⽤在函数参数的部分,⽤来接收不同类型数据的地址,这样的设计可以
实现泛型编程的效果。使得⼀个函数来处理多种类型的数据。
四.指针运算
指针的基本运算有三种,分别是:

  • 指针+- 整数
  • 指针-指针
  • 指针的关系运算

1.指针+- 整数
因为数组在内存中是连续存放的,只要知道第⼀个元素的地址,顺藤摸⽠就能找到后⾯的所有元素。

cs 复制代码
int arr[10] = {1,2,3,4,5,6,7,8,9,10};
cs 复制代码
#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;
}

也可以将数组里的数全改为0;

cs 复制代码
#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++)
	{
		*(p + i) = 0;
	}
	for (i = 0; i < sz; i++)
	{
		printf("%d ", *(p + i));
	}
	return 0;
}

当然也可以自己输入,但输入的时候就不用加&了。


反过来打印:

这里我直接用arr打印了,当然也可以用指针,但应该给一个 向后移动的指针变量。

cs 复制代码
#include <stdio.h>
int main()
{
	int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };
	int i = 0;
	int sz = sizeof(arr) / sizeof(arr[0]);
	int* p = &arr[sz - 1];
	for (i = 0; i < sz; i++)
	{
		*p = i + 1;
		p--;  //指针向前遍历
	}
	for (i = 0; i < sz; i++)
	{
		printf("%d ", arr[i]);
	}
	return 0;
}

2.指针-指针

cs 复制代码
#include <stdio.h>
int main()
{
	int arr[10] = { 0 };
	int n = &arr[9] - &arr[0];
	printf("%d", n);
	return 0;
}

打印结果:


也许你会疑惑为什么不是9*4=36,因为指针-指针求的是两者之间的 元素个数(而不是字节数)
引子:

可以自己写一个函数来实现strlen的作用。

cs 复制代码
#include <stdio.h>

size_t my_strlen(char* str)
{
	int count = 0;
	while (*str != '\0')
	{
		str++;
		count++;
	}
}
int main()
{
	char arr[] = "abcdef";
	size_t len = my_strlen(arr);
	printf("%zd", len);
	return 0;
}

指针-指针形式:

cs 复制代码
#include <stdio.h>
size_t my_strlen(char* str)
{
	char* start = str;
	while (str != '\0')
	{
		str++;
	}
	return str - start;
}

int main()
{
	char arr[] = "abcdef";
	size_t len = my_strlen(arr);
	printf("%zd", len);
	return 0;
}

3.指针的关系运算

cs 复制代码
#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;
}
相关推荐
1024小神几秒前
tauri项目在windows上的c盘没有权限写入文件
c语言·开发语言·windows
赵谨言3 分钟前
基于物联网架构的温室环境温湿度传感器节点设计
经验分享·毕业设计
写不出来就跑路15 分钟前
暑期实习感悟与经验分享:从校园到职场的成长之路
java·开发语言·经验分享·spring boot
KoiHeng2 小时前
操作系统简要知识
linux·笔记
巴伦是只猫3 小时前
【机器学习笔记Ⅰ】11 多项式回归
笔记·机器学习·回归
DKPT7 小时前
Java桥接模式实现方式与测试方法
java·笔记·学习·设计模式·桥接模式
努力的小雨8 小时前
点我!1分钱获取你的专属表白网页,浪漫由大模型代运营
经验分享·ai智能
巴伦是只猫9 小时前
【机器学习笔记Ⅰ】13 正则化代价函数
人工智能·笔记·机器学习
学不动CV了9 小时前
ARM单片机启动流程(二)(详细解析)
c语言·arm开发·stm32·单片机·51单片机
好好研究9 小时前
学习栈和队列的插入和删除操作
数据结构·学习