“只能说你没懂，不能说你没看见”

最新推荐文章于 2024-09-11 19:54:50 发布

Filex;

最新推荐文章于 2024-09-11 19:54:50 发布

阅读量851

点赞数 34

分类专栏： C语言文章标签：考研学习方法 c++ c语言开发语言

本文链接：https://blog.csdn.net/f_2789889770/article/details/137058876

版权

C语言专栏收录该内容

19 篇文章 0 订阅

订阅专栏

指针的理解

一、地址和指针变量
二、二维数组和指针数组
三、函数指针变量、函数指针数组

一、地址和指针变量

1.内存和地址

内存
我们知道计算上CPU（中央处理器）在处理数据的时候，需要的数据是在内存中读取的，处理后的数据也会放回内存中，那我们买电脑的时候，电脑上内存是8GB/16GB/32GB等，那这些内存空间如何⾼效的管理呢？
其实是把内存划分为⼀个个的内存单元，每个内存单元的⼤⼩取1个字节。
计算机中常⻅的单位（补充）：
⼀个⽐特位可以存储⼀个2进制的位1或者0

1 bit
2 byte
3 kb
4 mb
5 gb
6 tb
7 pb
…
它们之间的转换是这样的：

1byte = 8bit
1kb = 1024byte
1mb = 1024kb
1gb = 1024mb
1tb = 1024gb
…

其中，每个内存单元，相当于⼀个学⽣宿舍，⼀个字节空间⾥⾯能放8个⽐位，就好⽐同学们住的⼋⼈间，每个⼈是⼀个⽐特位。每个内存单元也都有⼀个编号（这个编号就相当于宿舍房间的⻔牌号），有了这个内存单元的编号，CPU就可以快速找到⼀个内存空间。

地址
⽣活中我们把⻔牌号也叫地址，在计算机中我们把内存单元的编号也称为地址。C语⾔中给地址起了新的名字叫：指针
一句话：内存单元的编号就是地址，也叫做指针。
在这里插入图片描述

2.指针变量和地址

2.1取地址操作符（&）
理解了内存和地址的关系，我们再回到C语⾔，在C语⾔中创建变量其实就是向内存申请空间，⽐如：

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

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

#include <stdio.h>
int main()
{
int a = 10;
&a;//取出a的地址
printf("%p\n", &a);
return 0;
}

在这里插入图片描述

&a取出的是a所占4个字节中地址较⼩的字节的地址
所以会打印处理：006FFD70
虽然整型变量占⽤4个字节，我们只要知道了第⼀个字节地址，顺藤摸⽠访问到4个字节的数据也是可⾏的。

2.2 指针变量和解引⽤操作符（*）

指针变量
我们通过取地址操作符(&)拿到的地址是⼀个数值，⽐如：0x006FFD70，这个数值有时候也是需要存储起来，⽅便后期再使⽤的，那我们把这样的地址值存放在哪⾥呢？答案是：指针变量中。

#include <stdio.h>
int main()
{
int a = 10;
int* pf = &a;//取出a的地址并存储到指针变量pa中
return 0;
}

指针变量也是⼀种变量，这种变量就是⽤来存放地址的，存放在指针变量中的值都会理解为地址。
这⾥pf左边写的是 int* ， * 是在说明pa是指针变量，⽽前⾯的 int 是在说明pa指向的是整型(int)类型的对象。
在这里插入图片描述
解引⽤操作符
我们将地址保存起来，未来是要使⽤的，那怎么使⽤呢？
在现实⽣活中，我们使⽤地址要找到⼀个房间，在房间⾥可以拿去或者存放物品。
C语⾔中其实也是⼀样的，我们只要拿到了地址（指针），就可以通过地址（指针）找到地址（指针）指向的对象，这⾥必须学习⼀个操作符叫解引⽤操作符(*)。

1 int main()
2 {
3 int a = 100;
4 int* pa = &a;
5 *pa = 0;
6 return 0;
7 }
上⾯代码中第5⾏就使⽤了解引⽤操作符， *pa 的意思就是通过pa中存放的地址，找到指向的空间，
*pa其实就是a变量了；所以*pa = 0，这个操作符是把a改成了0.

指针变量的⼤⼩
一句话：32位平台下地址是32个bit位，指针变量⼤⼩是4个字节
• 64位平台下地址是64个bit位，指针变量⼤⼩是8个字节
• 注意指针变量的⼤⼩和类型是⽆关的，只要指针类型的变量，在相同的平台下，⼤⼩都是相同的。

3. 指针变量类型的意义

3.1 指针的解引⽤
指针的类型决定了，对指针解引⽤的时候有多⼤的权限（⼀次能操作⼏个字节）。⽐如： char* 的指针解引⽤就只能访问⼀个字节，⽽ int* 的指针的解引⽤就能访问四个字节。
3.2 指针±整数
指针的类型决定了指针向前或者向后⾛⼀步有多⼤（距离）。
3.3 void 指针*
在指针类型中有⼀种特殊的类型是 void* 类型的，可以理解为⽆具体类型的指针（或者叫泛型指针），这种类型的指针可以⽤来接受任意类型地址。但是也有局限性， void* 类型的指针不能直接进⾏指针的±整数和解引⽤的运算。
⼀般 void* 类型的指针是使⽤在函数参数的部分，⽤来接收不同类型数据的地址，这样的设计可以实现泛型编程的效果。使得⼀个函数来处理多种类型的数据

4.const修饰指针变量

const修饰指针变量的时候
• const如果放在的左边，修饰的是指针指向的内容，保证指针指向的内容不能通过指针来改变。但是指针变量本⾝的内容可变。
• const如果放在的右边，修饰的是指针变量本⾝，保证了指针变量的内容不能修改，但是指针指向的内容，可以通过指针改变

int main()
{
 int m = 10;
 int n = 20;
 int*const p = &n;
 *p = m;//指针变量不能修改，但内容可以

int main()
{
 int m = 10;
 int n = 20;
 const int*p = &n;
 p = &m;//指针变量可以修改，但内容不可以

5. 指针运算

指针的基本运算有三种，分别是：
• 指针± 整数
• 指针-指针
• 指针的关系运算
5.1 指针± 整数
因为数组在内存中是连续存放的，只要知道第⼀个元素的地址，顺藤摸⽠就能找到后⾯的所有元素。
5.2 指针-指针

指针-指针等于两个指针之间的元素个数

5.3 指针的关系运算
比较指针之间的大小

6. 野指针

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

指针未初始化
指针越界访问
指针指向的空间释放

如何规避野指针

指针初始化：如果明确知道指针指向哪⾥就直接赋值地址，如果不知道指针应该指向哪⾥，可以给指针赋值NULL.
NULL 是C语⾔中定义的⼀个标识符常量，值是0，0也是地址，这个地址是⽆法使⽤的，读写该地址会报错。
⼩⼼指针越界：⼀个程序向内存申请了哪些空间，通过指针也就只能访问哪些空间，不能超出范围访问，超出了就是越界访问。
指针变量不再使⽤时，及时置NULL，指针使⽤之前检查有效性

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

7.传值调⽤和传址调⽤

传值调⽤是把变量本⾝直接传递给了函数，这种调⽤函数的⽅式我们之前在函数的时候就知道了。
一句话：实参传递给形参的时候，形参会单独创建⼀份临时空间来接收实参，对形参的修改不影响实参

传址调⽤将变量的地址传递给了函数
传址调⽤，可以让函数和主调函数之间建⽴真正的联系，在函数内部可以修改主调函数中的变量。

所以未来函数中只是需要主调函数中的变量值来实现计算，就可以采⽤传值调⽤。如果函数内部要修改主调函数中的变量的值，就需要传址调⽤。

二、二维数组和指针数组

1.数组的本质

数组名就是数组⾸元素(第⼀个元素)的地址。但是有两个例外：
• sizeof(数组名)，sizeof中单独放数组名，这⾥的数组名表⽰整个数组，计算的是整个数组的⼤⼩，单位是字节
• &数组名，这⾥的数组名表⽰整个数组，取出的是整个数组的地址（整个数组的地址和数组⾸元素的地址是有区别的）
除此之外，任何地⽅使⽤数组名，数组名都表⽰⾸元素的地址。

2.⼆级指针

指针变量也是变量，是变量就有地址，那指针变量的地址存放在哪⾥？
这就是⼆级指针
二级指针画图
对于⼆级指针的运算有：
• *ppa 通过对ppa中的地址进⾏解引⽤，这样找到的是 pa ， *ppa 其实访问的就是 pa .
**ppa 先通过 *ppa 找到 pa ,然后对 pa 进⾏解引⽤操作： *pa ，那找到的是 a .

3.指针数组

指针数组是存放指针的数组。
在这里插入图片描述
指针数组的每个元素是地址，⼜可以指向⼀块区域。

4.数组指针

4.1 字符指针变量
在指针的类型中我们知道有⼀种指针类型为字符指针 char* ;

int main()
{
char ch = 'w';
char *pc = &ch;
*pc = 'w';
return 0;
}

还有⼀种使⽤⽅式如下：

int main()
{
const char* pstr = "hello world.";//这⾥是把⼀个字符串放到pstr指针变量⾥了吗？
printf("%s\n", pstr);
return 0;
}

本质是把字符串 hello world. ⾸字符的地址放到了pstr中。

C/C++会把常量字符串存储到单独的⼀个内存区域，当⼏个指针指向同⼀个字符串的时候，他们实际会指向同⼀块内存。但是⽤相同的常量字符串去初始化不同的数组的时候就会开辟出不同的内存块。

4.2数组指针变量
数组指针变量是：存放的是数组的地址，能够指向数组的指针变量。

int (*p)[10];

解释：p先和结合，说明p是⼀个指针变量变量，然后指着指向的是⼀个⼤⼩为10个整型的数组。所以p是⼀个指针，指向⼀个数组，叫数组指针。
这⾥要注意：[]的优先级要⾼于 * 号的，所以必须加上（）来保证p先和结合。

数组指针的初始化：

int arr[10] = {0};
int(*p)[10] = &arr;

如果要存放个数组的地址，就得存放在数组指针变量中

5.⼆维数组传参的本质

⾸先我们再次理解⼀下⼆维数组，⼆维数组起始可以看做是每个元素是⼀维数组的数组，也就是⼆维数组的每个元素是⼀个⼀维数组。那么⼆维数组的⾸元素就是第⼀⾏，是个⼀维数组。
在这里插入图片描述

所以，根据数组名是数组⾸元素的地址这个规则，⼆维数组的数组名表⽰的就是第⼀⾏的地址，是⼀维数组的地址。根据上⾯的例⼦，第⼀⾏的⼀维数组的类型就是 int [5] ，所以第⼀⾏的地址的类型就是数组指针类型 int(*)[5] 。那就意味着⼆维数组传参本质上也是传递了地址，传递的是第⼀⾏这个⼀维数组的地址，那么形参也是可以写成指针形式的。如下：

#include <stdio.h>
void test(int (*p)[5], int r, int c)
{
int i = 0;
int j = 0;
for(i=0; i<r; i++)
{
for(j=0; j<c; j++)
{
printf("%d ", *(*(p+i)+j));
}
printf("\n");
}
}
int main()
{
int arr[3][5] = {{1,2,3,4,5}, {2,3,4,5,6},{3,4,5,6,7}};
test(arr, 3, 5);
return 0;
}

一句话：⼆维数组传参，形参的部分可以写成数组，也可以写成指针形式

三、函数指针变量、函数指针数组

1.函数指针变量的创建

函数指针变量应该是⽤来存放函数地址的，未来通过地址能够调⽤函数的。

函数是有地址的，函数名就是函数的地址，当然也可以通过 &函数名的⽅式获得函数的地址。

如果我们要将函数的地址存放起来，就得创建函数指针变量咯，函数指针变量的写法其实和数组指针⾮常类似。如下：

void test()
{
printf("hehe\n");
}
void (*pf1)() = &test;
void (*pf2)()= test;
int Add(int x, int y)
{
return x+y;
}
int(*pf3)(int, int) = Add;
int(*pf3)(int x, int y) = &Add;//x和y写上或者省略都是可以的

函数指针类型解析：

int (*pf3) (int x, int y)
|   |      ------------
|   |      |
|   |      pf3指向函数的参数类型和个数的交代
|   函数指针变量名
pf3指向函数的返回类型
int (*) (int x, int y) //pf3函数指针变量的类型

2.函数指针变量的使⽤

#include <stdio.h>
int Add(int x, int y)
{
return x+y;
}
int main()
{
int(*pf3)(int, int) = Add;
printf("%d\n", (*pf3)(2, 3));
printf("%d\n", pf3(3, 5));
return 0;
}