【C语言】指针详解（一）

devtools/2024/10/18 1:32:10/

个人主页 ： zxctscl
如有转载请先通知

文章目录

  • 1.内存与地址
  • 2.指针变量与地址
    • 2.1 取地址操作符&
    • 2.2 指针变量
    • 2.3 指针类型
    • 2.4 解引用操作符
    • 2.5 指针变量的大小
  • 3. 指针变量类型的意义
    • 3.1 指针的解引用
  • 4. const修饰指针
    • 4.1 const修饰变量
    • 4.2 const修饰指针变量
  • 5. 指针运算
    • 5.1 指针+-整数
    • 5.2 指针-指针
    • 5.3 指针的运算关系
  • 6. 野指针
    • 6.1 野指针成因
    • 6.2 如何规避野指针
      • 6.2.1 指针初始化
      • 6.2.2 小心指针越界
      • 6.2.3 指针变量不再使用时，及时置NULL，指针使用之前检查有效性
  • 7. assert断言
  • 8. 指针的使用和传址调用

1.内存与地址

大家对地址都不陌生，就像在生活中住酒店如何找到房间？那不就通过房卡上的房间号先确定楼层在确定房间。而这些房间号我们也叫地址。
把内存划分为一个个内存单元，一个单元为一个字节，而计算机中都是以一个比特位存储一个2进制位，一个字节也就是8个比特位。
这使得每个内存单元都有一个编号，通过这个编号，就能迅速找到这个内存空间。
在C语言中给地址起了新名叫：指针
内存编号

所以我们理解的：内存单元的编号 == 地址 == 指针

2.指针变量与地址

2.1 取地址操作符&

在C语言中创建变量其实就是在向内存申请空间。就像这样：

#include <stdio.h>
int main()
{int a = 5;return 0;
}

创建了整型变量a，内存中就申请了4个字节，用来存放整数5。每个字节都有地址，而上面申请的4个字节的地址分别在下面划红线四个。
在这里插入图片描述
如果我们想得到a的地址，就需要用到取地址操作符&。
像下面这样就可，但值得注意的是我们打印的是地址用到的是**%p**。

#include <stdio.h>
int main()
{int a = 5;&a;printf("%p\n", &a);return 0;
}

x86

2.2 指针变量

我们通过取地址操作符&，得到的仅仅是地址，它就只是一个数值，有时候为了方便使用，我们把它用指针变量存储。

#include <stdio.h>
int main()
{int a = 5;int* p = &a;return 0;
}

指针变量也是一种变量，不过是用来存放地址，存放在指针变量中的值被理解为指针。

2.3 指针类型

指针也是有类型的。
就像前面所写的:

int a = 5;
int* p = &a;

在p的左边就是int*,*说明的是p为指针变量，而前面的int就是说明p指向的是整型（int）类型的对象。
同理指向char型的指针变量就是char*。

char b = 'a';
char* p = &b;

2.4 解引用操作符

在C语言中，我们找到地址，就可以对地址所指向的对象，而此时所要用到的就是解引用操作符（*）。

#include <stdio.h>
int main()
{int a = 5;int* p = &a;*p=0;return 0;
}

而在上面的代码中，原来a为5，我们通过指针拿到了a的地址，然后通过解引用操作*p=0将原来a的5改为0。

2.5 指针变量的大小

32位机器假设有32根地址总线，每根地址线出来的电信号转换成数字信号后是1或者0，那我们把32根地址线产⽣的2进制序列当做⼀个地址，那么⼀个地址就是32个bit位，需要4个字节才能存储。
如果指针变量是⽤来存放地址的，那么指针变的⼤⼩就得是4个字节的空间才可以。
同理64位机器，假设有64根地址线，⼀个地址就是64个⼆进制位组成的⼆进制序列，存储起来就需要8个字节的空间，指针变的⼤⼩就是8个字节。

#include <stdio.h>
int main()
{printf("%zd\n", sizeof(char *));printf("%zd\n", sizeof(short *));printf("%zd\n", sizeof(int *));printf("%zd\n", sizeof(double *));printf("%zd\n", sizeof(float *));return 0;
}

32位平台下地址，指针变量大小是4个字节

x86
64位平台下地址，指针变量大小是8个字节
x64
结论：

  1. 32位平台下地址，指针变量大小是4个字节
  2. 64位平台下地址，指针变量大小是8个字节
  3. 注意指针变量的大小和类型是无关的，只要指针类型的变量，在相同的平台下，大小都是相同的。

3. 指针变量类型的意义

指针变量的大小和类型无关，只要是指针变量，在同一个平台下，大小都是一样的，为什么还要有各种各样的指针类型呢

3.1 指针的解引用

对比，下面2段代码，主要在调试时观察内存的变化。

//代码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* 的指针的解引用就能访问四个字节。

4. const修饰指针

4.1 const修饰变量

变量是可以修改的，如果把变量的地址交给一个指针变量，通过指针变量的也可以修改这个变量。
但是如果我们希望一个变量加上一些限制，不能被修改，怎么做呢？这就是const的作用。

#include <stdio.h>
int main()
{int m = 0;m = 20;//m是可以修改的const int n = 0;n = 20;//n是不能被修改的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* p = &n;*p = 20;printf("n = %d\n", n);return 0;
}

在这里插入图片描述
可以看到这里一个确实修改了，但是我们还是要思考一下，为什么n要被const修饰呢？就是为了不能被修改，如果p拿到n的地址就能修改n，这样就打破了const的限制，这是不合理的，所以应该让p拿到n的地址也不能修改n，那接下来怎么做呢？

4.2 const修饰指针变量

测试无const修饰的情况：

#include <stdio.h>
//代码1
void test1()
{int n = 10;int m = 20;int* p = &n;*p = 20;//ok?p = &m; //ok?
}

测试const放在*的左边情况：

void test2()
{//代码2int n = 10;int m = 20;const int* p = &n;*p = 20;//ok?p = &m; //ok?
}

在这里插入图片描述

测试const放在*的右边情况

void test3()
{int n = 10;int m = 20;int* const p = &n;*p = 20; //ok?p = &m; //ok?
}

在这里插入图片描述

测试*的左右两边都有const

void test4()
{int n = 10;int m = 20;int const* const p = &n;*p = 20; //ok?p = &m; //ok?
}

在这里插入图片描述
const修饰指针变量的时候：

  1. const如果放在*的左边，修饰的是指针指向的内容，保证指针指向的内容不能通过指针来改变。但是指针变量本身的内容可变。
  2. const如果放在*的右边，修饰的是指针变量本身，保证了指针变量的内容不能修改，但是指针指向的内容，可以通过指针改变。

5. 指针运算

指针的基本运算有三种，分别是：
• 指针± 整数
• 指针-指针
• 指针的关系运算

5.1 指针±整数

数组在内存中是连续存储的，只要知道第一个元素的地址，后面的元素依次就能找到。

int arr[]={1,2,3,4,5};

而所对应的下标为0，1，2，3，4。

在对不同类型指针变量加减时结果不同，
举个例子：

#include <stdio.h>
int main()
{int n = 10;int* p1 = &n;char* p2 = &n;printf("p1=%p\n", p1);printf("p1+1=%p\n", p1+1);printf("p2=%p\n", p2);printf("p2+1=%p\n", p2+1);return 0;
}

在下面为结果
int类型的就跳过了4个字节，
char类型就跳过1个字节
指针+-
结论：
指针的类型决定了，指针加减整数时，一次性跳过多少个字节。

5.2 指针-指针

在指针变量相同类型时，计算出的是中间间隔的个数。
举个例子：

#include <stdio.h>
int main()
{int arr[10] = { 0 };int* p1 = &arr[9];int* p2 = &arr[0];int ret = p1-p2 ;printf("%d\n", ret);return 0;
}

结果为
间隔9
指针类型不同时不能进行指针的加减运算。

5.3 指针的运算关系

计算数组的元素个数时，我们使用了sizeof(数组名)，而sizeof中单独放数组名，这里的数组名表示整个数组，计算的是整个数组的大小，单位是字节。
sizeof(arr[0]）计算的是首元素的大小，单位也是字节。

#include <stdio.h>
int main()
{int arr[] = { 1,2,3,4,5,6,7,8,9,10 };int sz = sizeof(arr) / sizeof(arr[0]);printf("%d\n", sz);return 0;
}

数组大小
数组名就是数组首元素(第一个元素)的地址是对的，但是有两个例外：
1.sizeof(数组名)，sizeof中单独放数组名，这里的数组名表示整个数组，计算的是整个数组的大小，单位是字节。
2.&数组名，这里的数组名表示整个数组，取出的是整个数组的地址。
除此之外，任何地方使用数组名，数组名都表示首元素的地址。

6. 野指针

概念： 野指针就是指针指向的位置是不可知的（随机的、不正确的、没有明确限制的）

6.1 野指针成因

  1. 指针未初始化
#include <stdio.h>
int main()
{int* p;//局部变量指针未初始化，默认为随机值*p = 20;return 0;
}

在这里插入图片描述

  1. 指针越界访问
#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;
}

在这里插入图片描述

  1. 指针指向的空间释放
#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也是地址，这个地址是无法使用的，读写该地址会报错。

#ifdef __cplusplus#define NULL 0
#else#define NULL ((void *)0)
#endif

初始化如下：

#include <stdio.h>
int main()
{int num = 10;int*p1 = &num;int*p2 = NULL;return 0;
}

6.2.2 小心指针越界

一个程序向内存申请了哪些空间，通过指针也就只能访问哪些空间，不能超出范围访问，超出了就是越界访问。

6.2.3 指针变量不再使用时，及时置NULL，指针使用之前检查有效性

当指针变量指向一块区域的时候，我们可以通过指针访问该区域，后期不再使用这个指针访问空间的时候，我们可以把该指针置为NULL。因为约定俗成的一个规则就是：只要是NULL指针就不去访问，同时使用指针之前可以判断指针是否为NULL。
我们可以把野指针想象成野狗，野狗放任不管是⾮常危险的，所以我们可以找一棵树把野狗拴起来，就相对安全了，给指针变量及时赋值为NULL，其实就类似把野狗栓前来，就是把野指针暂时管理起来。
不过野狗即使拴起来我们也要绕着走，不能去挑逗野狗，有点危险；对于指针也是，在使用之前，我们也要判断是否为NULL，看看是不是被拴起来起来的野狗，如果是不能直接使用，如果不是我们再去使用。

#include <stdio.h>
int main()
{int arr[10] = { 1,2,3,4,5,67,7,8,9,10 };int* p = &arr[0];for (i = 0; i < 10; i++){*(p++) = i;}//此时p已经越界了，可以把p置为NULLp = NULL;//下次使⽤的时候，判断p不为NULL的时候再使⽤//...p = &arr[0];//重新让p获得地址if (p != NULL) //判断{//...}return 0;
}

7. assert断言

assert.h 头文件定义了宏 assert() ，用于在运行时确保程序符合指定条件，如果不符合，就报
错终止运行。这个宏常常被称为“断言”。

assert(p != NULL);

代码在程序运行到这一行语句时，验证变量 p 是否等于 NULL 。如果确实不等于 NULL ，程序继续运行，否则就会终止运行，并且给出报错信息提示。
assert() 宏接受一个表达式作为参数。如果该表达式为真（返回值非零）， assert() 不会产生任何作用，程序继续运行。如果该表达式为假（返回值为零）， assert() 就会报错，在标准错误流 stderr 中写入一条错误信息，显示没有通过的表达式，以及包含这个表达式的文件名和行号。
assert() 的使用对程序员是非常友好的，使用assert() 有几个好处：它不仅能自动标识文件和出问题的行号，还有一种无需更改代码就能开启或关闭 assert() 的机制。如果已经确认程序没有问题，不需要再做断言，就在 #include<assert.h> 语句的前面，定义一个宏 NDEBUG 。

#define NDEBUG
#include <assert.h>

然后，重新编译程序，编译器就会禁⽤⽂件中所有的 assert() 语句。如果程序⼜出现问题，可以移除这条 #define NDBUG 指令（或者把它注释掉），再次编译，这样就重新启⽤了 assert() 语句。

assert() 的缺点是，因为引入了额外的检查，增加了程序的运行时间。
⼀般我们可以在debug中使用，在release版本中选择禁⽤assert就行，在VS这样的集成开发环境中，在release版本中，直接就是优化掉了。这样在debug版本写有利于程序员排查问题，在release版本不影响用户使用时程序的效率。

8. 指针的使用和传址调用

学习指针的目的是使用指针解决问题，那什么问题，非指针不可呢？
例如：写一个函数，交换两个整型变量的值
一番思考后，我们可能写出这样的代码

#include <stdio.h>
void Swap1(int x, int y)
{int tmp = x;x = y;y = tmp;
}int main()
{int a = 0;int b = 0;scanf("%d %d", &a, &b);printf("交换前：a=%d b=%d\n", a, b);Swap1(a, b);printf("交换后：a=%d b=%d\n", a, b);return 0;
}

在这里插入图片描述
其实没产生交换的效果，这是为什么呢？
调试一下，试试呢？
在这里插入图片描述
我们发现在main函数内部，创建了a和b，a的地址是0x00cffdd0，b的地址是0x00cffdc4，在调用Swap1函数时，将a和b传递给了Swap1函数，在Swap1函数内部创建了形参x和y接收a和b的值，但是x的地址是0x00cffcec，y的地址是0x00cffcf0，x和y确实接收到了a和b的值，不过x的地址和a的地址不一样，y的地址和b的地址不一样，相当于x和y是独立的空间，那么在Swap1函数内部交换x和y的值，自然不会影响a和b，当Swap1函数调用结束后回到main函数，a和b的没法交换。Swap1函数在使用的时候，是把变量本身直接传递给了函数，这种调用函数的方式我们之前在函数的时候就知道了，这种叫传值调用。

结论：实参传递给形参的时候，形参会单独创建一份临时空间来接收实参，对形参的修改不影响实参。所以Swap是失败的了。

那怎么办呢？
我们现在要解决的就是当调用Swap函数的时候，Swap函数内部操作的就是main函数中的a和b，直接将a和b的值交换了。那么就可以使用指针了，在main函数中将a和b的地址传递给Swap函数，Swap函数里边通过地址间接的操作main函数中的a和b就好了

#include <stdio.h>void Swap2(int* px, int* py)
{int tmp = 0;tmp = *px;*px = *py;*py = tmp;
}
int main()
{int a = 0;int b = 0;scanf("%d %d", &a, &b);printf("交换前：a=%d b=%d\n", a, b);Swap2(&a, &b);printf("交换后：a=%d b=%d\n", a, b);return 0;
}

在这里插入图片描述
有问题请指出，大家一起进步！！！


http://www.ppmy.cn/devtools/119804.html

相关文章

OpenCV视频I/O(3）视频采集类VideoCapture之获取当前使用的视频捕获 API 后端的名称函数getBackendName()的使用

OpenCV视频I/O(3）视频采集类VideoCapture之获取当前使用的视频捕获 API 后端的名称函数getBackendName()的使用

操作系统&#xff1a;ubuntu22.04 OpenCV版本&#xff1a;OpenCV4.9 IDE:Visual Studio Code 编程语言&#xff1a;C11 算法描述 getBackendName 函数是 OpenCV 中 VideoCapture 类的一个方法&#xff0c;用于获取当前使用的视频捕获 API 后端的名称。这可以帮助开发者了解当…
阅读更多...
初识Linux · 进程等待

初识Linux · 进程等待

目录 前言&#xff1a; 进程等待是什么 为什么需要进程等待 进程等待都在做什么 前言&#xff1a; 通过上文的学习&#xff0c;我们了解了进程终止&#xff0c;知道终止是在干什么&#xff0c;终止的三种情况&#xff0c;以及有了退出码&#xff0c;错误码的概念&#xff…
阅读更多...
UE4_Niagara基础实例—5、骨架网格体表面生成粒子及过滤骨骼位置生成粒子

UE4_Niagara基础实例—5、骨架网格体表面生成粒子及过滤骨骼位置生成粒子

效果图&#xff1a; 步骤&#xff1a; 1、学习了静态网格体位置生成粒子之后这个就比较简单了&#xff0c;把粒子生成位置更改为SkeletalMeshLocation。 2、小白人的骨骼网格体为&#xff1a; 你会发现骨骼的每一个节点处都有粒子产生。 3、我们还可以修改骨骼采样类型 4、我们…
阅读更多...
HTML·第三章课后练习题

HTML·第三章课后练习题

采用表格布局完成“CASIO计算器”外观设计&#xff0c;其中表格的每一个单元格均需要设计带边框 <!DOCTYPE html> <html lang"zh"><head><meta charset"UTF-8"><meta name"viewport" content"widthdevice-width…
阅读更多...
python单例和工厂模式

python单例和工厂模式

设计模式 设计模式是一种编程套路&#xff0c;可以极大的方便程序的开发 最常见、最经典的设计模式&#xff0c;就是学习的面向对象 除了面向对象之外&#xff0c;在编程中也有很多既定的套路可以方便开发&#xff0c;我们称之为设计模式&#xff1a; 单例、工厂模式建造者…
阅读更多...
Redis篇（缓存机制 - 多级缓存）（持续更新迭代）

Redis篇（缓存机制 - 多级缓存）（持续更新迭代）

目录 一、传统缓存的问题 二、JVM进程缓存 1. 导入案例 2. 初识Caffeine 3. 实现JVM进程缓存 3.1. 需求 3.2. 实现 三、Lua语法入门 1. 初识Lua 2. HelloWorld 3. 变量和循环 3.1. Lua的数据类型 3.2. 声明变量 3.3. 循环 4. 条件控制、函数 4.1. 函数 4.2. 条…
阅读更多...
极狐GitLab 17.4 重点功能解读【一】

极狐GitLab 17.4 重点功能解读【一】

GitLab 是一个全球知名的一体化 DevOps 平台&#xff0c;很多人都通过私有化部署 GitLab 来进行源代码托管。极狐GitLab 是 GitLab 在中国的发行版&#xff0c;专门为中国程序员服务。可以一键式部署极狐GitLab。 学习极狐GitLab 的相关资料&#xff1a; 极狐GitLab 官网极狐…
阅读更多...
数据集-目标检测系列-豹子 猎豹 检测数据集 leopard＞＞ DataBall

数据集-目标检测系列-豹子 猎豹 检测数据集 leopard＞＞ DataBall

数据集-目标检测系列-豹子 猎豹 检测数据集 leopard>> DataBall 数据集-目标检测系列-豹子 猎豹 检测数据集 leopard 数据量&#xff1a;5k 想要进一步了解&#xff0c;请联系。 DataBall 助力快速掌握数据集的信息和使用方式&#xff0c;会员享有 百种数据集&#x…
阅读更多...
最新文章

Copyright @ 2022~2023