[C/C++] 指针的原理和对指针的运用及理解(包括函数指针和多级指针)

男娘i 2023-01-22 15:58 158阅读 0赞

### 目录 ###

*   *  C/C++指针存在的必要性
     *  内存和指针原理的简易认知
     *  指针的理解
     *  指针相关运算符
     *  数据指针和函数指针的声明方式
     *  指针原理
     *  \*\*指针风暴\*\*
     *  数据类型权限和指针级数

--------------------

## C/C++指针存在的必要性 ##

指针的重要性,是毋庸置疑的.  
有很多时候你都需要对内存进行管理,没有指针,就有受苦的时候了.  
没有指针,依托节点数据结构铸造出来的数据类型,就是无稽之谈.  
总不可能为了实现这些非线性数据结构,去写内联汇编吧.

C/C++和很多语言最大的区别,就是对于指针的运用.

C/C++不像其他语言哪样,对程序员保护的像个小宝宝一样,生怕你让自己的程序变成内存毁灭者.  
它们给与程序员极高的自由,只要遵守语法规则,即便是让内存乱成一锅粥,也无所谓.  
高自由度,也带来了高混乱,如果你没有搞懂数据类型间的权限关系,级别,就会发现,自己只是在写可以编译的bug.

--------------------

## 内存和指针原理的简易认知 ##

指针的原理直指内存,所以需要先对内存有一个概念.

计算机之所以能进行工作,是因为它拥有存储空间,以来进行对其上存储的数据进行读写操作.  
如果计算机没有任何意义上的存储单位,那么它就是个砖头,毕竟做个1+1,还得让它能有地方放数字呢.

计算机的底层语言是机器语言,这是计算机唯一真正能看懂的东西.  
也就是二进制.  
之所以计算机采用二进制是因为这和它的存储方式有关系.  
**最小的存储单位是 位元(英文:bit 简称:位)**  
**最小的使用单位是 字节(英文:byte)**

程序员最小可操控的存储单位是bit,但一般不会涉及到.  
正常的最小操控都是以字节为单位.

2021年,个人电脑,最小都是TB为单位的存储容器吧.  
不管它是机械还是固态.  
这里面存储的位,都太过于庞当了.  
而为了管理这些存储,就有了存储地址.

不过这是外存(断电数据不归零)  
程序员一般和内存打交道.(断电数据归零)

但是存储单位是一样的.

你的程序平时存在外存上,而在运行的时候,会被copy到内存中,等待Cpu临幸.

32位程序会分配一个4GB大小的虚拟内存(寻址空间).  
0x0000 0000 - 0xFFFF FFFF  
64位则是这么大  
0x0000 0000 0000 0000 0xFFFF FFFF FFFF FFFF

指针的长度,在32位系统上,是4字节,64位系统则是8字节.  
指针作为存储地址的变量,那么首先必须得先可以存这么大的数才可以.  
2^32 : 0XFFFF FFFF  
2^64 : 0XFFFF FFFF FFFF FFFF

这些虚拟内存,不是全给你用的.有 一部分会被系统拿走.  
然后虚拟内存地址会映射到实际的物理存储上.

而内存中,又分为多个区段.  
栈区,堆区,数据区,代码区,静态区(static修饰 就是放到这里),字符常量区  
你的指针指的就是这些内存地址.

指针,字面的意义上的理解,就是一根针,指向一个东西.  
指的就是内存地址.  
可以理解为指针类型,就是个变量,只不过这个变量,只允许放地址.  
内存地址是一段16进制的正整数,当然,你也可以给它换算成其他进制.  
但是16进制作为存储地址,是有它的道理的.  
0xFF正好表达1字节最大数.  
那么0x00-0xFF就是1字节的范围.

## 指针的理解 ##

首先我们需要明确的一点是,指针是独立的数据类形.  
而我们常说的整数型指针,字符型指针,浮点型指针,这指的是指针读取值地址中的数据方式.  
计算机中的数据类型,归根结底只有两种,那就是整数型和浮点型.(指针就是整数类型)  
这就涉及到关于计算机中是如何存储数据的知识点了.  
不在本章讨论范围内.

不要因为int\* short\* char\*就觉得指针类型,是依托于这些数据类型下的.  
指针独立于这些数据类型,不存在任何的从属关系.

最简单的证明,你可以sizeof一下指针,32位是4字节,64字节是8字节.  
**所有指针,在程序位元相同的情况下,占用的字节,永远是一样的.**

作为**指针类型的变量,它只接受内存地址**.

## 指针相关运算符 ##

取地址运算符:&\[右值\] 返回右值自身地址  
取值运算符:\*\[右值\] 返回右值指针的值中值给左值

取地址运算符&也是引用运算符.  
关于引用的详细信息:[引用和指针的关系][Link 1]  
取值运算符\*也是指针级数运算符.  
声明指针的时候 数据类型之后的就是指针级数.  
一级指针 \*  
二级指针 \*\*  
以此类推

dataType* varName { address}; // 一级指针
    dataType** varName { address}; // 二级指针

除了上面的这些,还有一种就是 p->xxxx  
不过这个运算符只有类才会常见.  
不在本章讨论范围

--------------------

## 数据指针和函数指针的声明方式 ##

**数据指针的声明方式**  
**\[数据类型\] \[指针级数\] \[指针变量名称\] = \[地址\] C Style**

int* pointer = 0x66666666;

个人叫法:先知赋值. // 因为你需要未卜先知才行(如果你明确这个地址是有效的,那么,你从事的行业就有点意思了)  
正常叫法:常量赋值;  
这是一种非常少用的赋值方式,直接用常量来为指针赋值.  
一般这种赋值方式常见在获取对方程序数据地址后(XDebug,CheatEngine这种调试工具)  
写第三方DLL,通过该指针来对改地址内的数据进行读写操作.  
虽然这种赋值方式有很多的不确定性,极有可能引发整个程序的崩溃(内存泄漏,权限冲突)  
但这种方式,确实是合法的.  
就如同之前说过的一样,**指针只接受内存地址**,而**内存地址,就是整数类型**.  
而整数常量,就是整数类型,完全有理有据

**注意!**  
这种赋值方式,只能是底层数据类型是整数类型的才可以.  
也就是 char,short,int,long 这些.  
换言之,void,float,double这些非整数类型,是不可以用这种方式的.

int* pointer = &variable; // 使用取地址运算符 获得变量的地址,然后

正常叫法:变量地址赋值.  
这是最常见的赋值方式.  
通过取变量地址的方式,来进行赋值.  
这种方式的优点就是,精准的获取变量地址.  
不管程序启动多少次,这个变量的地址是否发生变动,都可以正常的运行.  
但是也会对该变量类型进行检测.(编译器检测)  
例子:

[数据类型] [指针级数] [指针变量名称]  = [地址]
      int         *          point       &variable

编译器会去检测variable变量,是否是int类型.  
这是为了防止指针不能以正确的方式读取该地址的数据.

void* point = 任何数据类型

个人叫法:万能指针赋值.  
将数据类型写成void类型之后,编译器就不会对地址的来源变量,进行数据类型检测.  
除非你真的想不出应该用什么数据类型来作为指针的读写方式,不然,绝对不推荐这种声明方式.  
很容易导致数据读写冲突.

**\[数据类型\] \[指针级数\] \[指针变量名称\] \{地址\} C++ Style**

int* pointer { 0x66666666};

这是C++的声明方式,你可以将赋值号去掉,换成花括号.

**指针的使用注意!!!**  
**永远不要让指针变野指针.  
指向的地址永远要有掌控能力,你必须指到指针会指向什么.**

如果你申请了一个指针,不能立马给它赋地址,那你就应该用如下方式来声明.  
不然鬼知道这片地址划给你前里面放的是个什么东西.

int* point = 0x0; //C Style 0x0代表空地址,任何读写方式的指针都可以直接指向这个常量
    int* point { nullptr}; // C++ Style nullptr是C++才有的关键字,空指针的意思

--------------------

**函数指针的声明方式**  
**typedef \[数据返回类型\] (\[指针级数\] \[指针变量名称\]) (\[参数类型\]) C Style**  
**using \[指针变量名称\] = \[数据返回类型\] (\[指针级数\] ) (\[参数类型\]) C++ Style**

int Add(const int &a,const int &b)
    { 
        return a + b;
    }
    
    typedef int(*int_point_int_int)(const int&,const int&);		// C Style
    using Int_Point_Int_Int = int(*)(const int&, const int&);	// C++ Style
    
    int main(void)
    { 
    	const int_point_int_int ipiiC = Add;	
        const Int_Point_Int_Int ipiiCpp{  Add };
        std::cout << ipii(1, 1) << std::endl;
        return 0;
    }

函数赋值给指针的时候,不用写取地址运算符,因为**函数名就是个指针**.  
函数名是个一级指针.  
汇编代码就能看到

汇编例子:
    xxx xxxx 如果函数是外平栈 这就是平栈汇编
    call xxxxxx
    xxx xxxx

call的就是函数地址, 而地址,在C/C++中就是个一级指针的级别.  
如果你写取地址运算符,也没有关系,编译器理解你想要啥的.

如果你不明白编译器凭啥可以理解的你的意思.  
其实也很简单,毕竟你也做不了别的.  
也别不信邪,这是在原理上不允许的.

你总不至于想着取函数地址里面放的东西吧.  
函数名这个一级指针里面放的东西是函数的代码段首地址  
从函数头开始一直到retn返回道  
这一整个区段,都可以理解为是函数名这个一级指针的值,编译器还想问,你凭啥觉得你能取这玩意.lol

--------------------

## 指针原理 ##

其实这个标题并不准确,因为上面也有很多关于指针的原理.  
但是有些东西吧,就是和原理有牵连,所以只好就在上面一块讲了.  
![指针&内存][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQyNDY4MjI2_size_16_color_FFFFFF_t_70]  
一块内存可以被很多指针指向  
而指针本身,也有属于自己的内存空间.  
它的工作原理就是在计算机申请一块内存空间,然后这个内存空间放的是另一个内存空间的地址.  
我们可以通过指针来对其里面的内存空间进行有权限(读写)操作.

**内存地址是盒子编号,盒子里面放的东西是值.  
这个盒子里面可能又放了一个盒子.这个小盒子,同样叫做值.  
然后这个小盒子里的东西,对于大盒子来讲,叫做值中值,也可以说是值地址  
大号盒子本身的地址,叫做变量地址,或者自身地址**

**是不是觉得有点绕,什么值中值,值地址,这地址那地址的,绕就对了,就是套娃就是玩,不上图,真的不好理解**

## **指针风暴** ##

int* p{  new int{ 666} };
    int* pa{  p };

配合下图理解这两行代码,你就已经可以耍一级指针了.  
![指针&内存][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQyNDY4MjI2_size_16_color_FFFFFF_t_70 1]  
**解释:**  
我们向系统申请了一个以int类型方式读取值的一级指针p  
p指针被赋予了一个new出来的int类型地址,地址中的值是666.

现在**这个指针p可以进行三种操作**.

1.  取地址 &p(0x01)
2.  取值 p(0x03)
3.  取值中值 \*p(666)

随后我们又申请了指针pa.  
pa\{p\};  
而只写指针名是取值操作.  
所以可以翻译成下面语句  
pa\{0x03\};

**指针pa还是那三个操作**

1.  取地址 &pa(0x05)
2.  取值 pa(0x03)
3.  取值中值 \*pa(666)

--------------------

那如果我想让指针pa存的值是指针p的地址呢?  
这就涉及到指针级数的问题了.  
因为编译器对于非void数据读写方式的指针,都会检测地址来源的变量类型.  
pa\{&p\}这是不合法的.  
编译器检测到了p的变量,是个指针,这个指针的读写方式是int.  
而pa的读写方式只是int,而不是以int指针的方式来读写.

说简单点就是,你应该让它的读写方式是个int\*

int**pa{ &p}; // 合法

**更改后的pa指针能多取一次值了**

1.  取地址 &pa(0x05) //取自身地址
2.  取值 pa(0x01) // 0x01是p的地址
3.  取值中值 \*pa(0x03) // 取0x01中的值,就是p存放的值,p存放的是0x03
4.  取值中值中值 \*\*pa(666) // 再多取一次,就是\*p的值了,也就是0x03内的值.

## 数据类型权限和指针级数 ##

上面更改后的pa就是二级指针.  
如何判断它是几级指针,就看它指针级数的部分,有几个星星.  
如果你还是有点不好理解,咱们还可以抽象一下多级指针的结构(同样适用一级指针).

int\*\*pa\{&p\};  
一个\*代表一个地址.  
\*\*pa就是表示,我可以套两层地址.  
int则表示,最后一个地址后的值,是个int类型.  
应该按照int类型的方式来读写.  
加上自身的地址,和pa有关联的东西,就是3个地址加1个int类型数据.

咱们做个消消乐,来方便大家理解多级指针.

pa;//这就是从 int\*\* pa的指针级数中,拿掉了一个\*  
\*pa;//又从int\*\* pa的指针级数中拿掉了一个\*

拿了两个级数之后,它还剩下什么了?没错,就剩下了个int.  
\*\*pa;//以int类型的方式,读取这个数据,不在是之前以指针的方式读取数据了

多级指针以此类推.  
虽然说的有点啰嗦,像是幼儿园的幼师一样.  
但我希望你真的能耐下心,按照这个方式去理解,这是真正不会曲解指针含义,又能让新手入门的方式了.

这种方式叫 think of cpp.  
用C++视觉去拆分代码,挨个运算符的去分析其内部代表的含义.  
虽然很抽象,但是不会让你之后回过头发现,自己之前理解的是错误的.  
本人第一门语言就是C语言,没有任何的编程基础,也从没想过追究底层原理.  
所以最开始对于指针的理解,跟着别人视频上讲的去理解,后发现,他抽象出了表面,而没有去抽象出根本.  
导致我之后学习多级指针,多维数组,和所有的非线性数据结构都特别痛苦.

--------------------

上面的那些,绝不是放错地方的段落.  
因为这其中就有为什么应该去真正的理解指针的道理.  
我们现在手里有一个地址,就可以管它叫1级指针.  
这也是为什么之前,我称函数名是个1级指针的原因,因为**函数名就是自身代码段的地址.**

而地址中的值,理所当然就是**0级指针**了.(0级指针不能继续往下读地址了,再读地址就是非法寻址)  
也可以说它就是个值,不过因为在汇编层面,不过是一个地址赋值给另一个地址,一个寄存器,赋值另一个寄存器.  
所以将它称作0级指针是正确的.  
函数名这个一级指针比较独特,它是为了让ip寄存器跳到函数代码段首地址的.  
你读值,也没用,因为你最多只能读出一条汇编代码(不要想着指针++遍历代码段,这玩意不是这么遍历的)

回归正题  
那么这个地址中的值,还是个地址呢?(如果你明确的知道这个值就是个地址的话)  
我们将这个地址抽象层面提权为2级指针,也同样的给这个值提权为1级指针.  
而这个1级指针下面的值,则是0级.

为什么我说抽象提权呢.  
因为在计算机眼中,这些程序都是既定好的.  
大家都是内存地址,你们是同级别的东西.  
只需要读了这个地址,就应该继续读地址,然后读数据.  
可是人需要去抽象的理解它.

关于指针级数的讲解,已经讲完了.  
下面是数据类型权限.

比如const char\* 为什么不能赋值给char\[\];  
大家都是字符串,而且,大家轮底层也都是整数类型.  
如果你对为什么数据类型不能互相赋值,还需要不同的转换感到困惑,那么下面的答案就能解决.

--------------------

**数据类型权限**  
对于数据类型赋值报错,或者说赋值冲突的问题.  
为了搞明白这个问题,我们就需要知道一个知识点.  
那就是数据类型,它是分权限的.  
比如,可读可写,只读,这两种.  
而只读,就是数据类型加const修饰过的.

拿const char\*和char\*举例子.

char\* 可以赋值给const char\*,但是const char\*不能赋值给char\*.  
char\*它是什么权限?当然是可读可写了.  
而const char\*是只读权限.  
这俩谁权限高?肯定是可读可写的char权限高啊  
权限高的可以赋值给权限低的,这叫做**权限缩小赋值**  
而**权限低的不能赋值给权限高的**

数据类型相同的情况下,只能进行两种赋值

1.  **权限缩小赋值  
    cosnt char = char;**
2.  **等同权限赋值  
    char = char;**

可能有的人疑问了,const char\* 也可以之后赋值第二次啊.  
那么建议重新回去看看指针.  
const char和\*得分开,这个\*是个一级指针.  
而const char 才是你不能改的地方.  
你二次赋值的玩意,是个地址,指针又不是const修饰,当然可以赋值新的一级了.

既然讲完了权限赋值.  
我想大家也顺便理解了,为什么相同数据读写方式,相同指针级数的指针,可以互相赋值而不用加上取地址.  
因为这是等同权限赋值  
比如  
int\*p \{new int\{\}\} new出来的就是个一级指针,而\*p也是一级指针,它俩的赋值操作就是等同权限赋值.

**取地址是抽象层面的指针提级.  
int a\{0\}; // a这个变量名是一级地址,但是a本身使用的时候,是用值替换的,所以指针不能直接 p = a;  
需要写成 p = &a;给这个变量名提级为2级指针,然后编译器又会给它降级为1级指针,这样才可以达到同级赋值**

**取值则是抽象层面的指针降级.  
取值运算符的降级操作同理**

以上,就是全部内容了

--------------------

[Link 1]: https://blog.csdn.net/qq_42468226/article/details/116539271?spm=1001.2014.3001.5501
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQyNDY4MjI2_size_16_color_FFFFFF_t_70]: /images/20221020/ab2539a32ab44b46bcc33ff7b613c62c.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQyNDY4MjI2_size_16_color_FFFFFF_t_70 1]: /images/20221020/60854d8b837845baa0fed9b756f16778.png