【C语言】详细讲解指针-----从0到1突破式理解指针，讲解+代码+例题

write in front
大家好，我是gugugu。希望你看完之后，能对你有所帮助，不足请指正！共同学习交流
本文由 gugugu 原创 CSDN首发 如需转载还请通知⚠
个人主页：gugugu—精品博客
欢迎各位→点赞 + 收藏⭐️ + 留言​
系列专栏：gugugu的精品博客
✉️我们并非登上我们所选择的舞台，演出并非我们所选择的剧本

前言

今天这篇博客带来指针的分享，相信各位小伙伴在学习C语言之前就已经对指针有所耳闻，网上各种传言指针超级难，从而劝退C语言的学习，但是博主认为指针并不是难到不可以学会，多写代码，多多思考，就很容易学会指针的

指针的难点主要在于内容多，而并非难度大，努力啃每一个小版块，就很容易理解指针的

另外，本次博客将以讲解+代码+例题的方式讲解，从而加深对指针的理解

一、操作符&和*

在进入指针的学习之前，我们首先学习两个操作符 & 和 *，这两个操作符在指针中非常重要

1、操作符 &

&是取地址操作符，能够将一个元素的内存空间的地址给取出来

#include 
int main()
{
	int a = 10;
	char ch = 'a';
	int arr[] = { 1,2,3,4 };
	printf("%p\n", &a);
	printf("%p\n", &ch);
	printf("%p\n", &arr);
	return 0;
}

这里需要注意的是，对数组名进行取地址，比如举例中的&arr，是取了整个数组的地址，但是打印或者说在内存里面存放的还是数组首元素的地址 ，但本质仍然是取出了整个数组的地址

通过这个例子，可以看到&arr+1，并不是+4，而是增加了16，所以确实跳过了整个数组

2、操作符 *

*操作符叫做解引用操作符，是对地址进行解引用的，找到地址所对应的元素

#include 
int main()
{
	int a = 10;
	int* p = &a;
	(*p)++;
	printf("%d\n", a);
	
	return 0;
}

这里int * p=&a，这一步不用管，就是指针，后面会讲到，只用先理解解引用操作符

这里通过*p解引用，找到了p指向的元素a，之后进行++，所以得到11

二、指针

1、简单介绍一下指针

指针其实全称指针变量，也是一种变量，类似于整型变量，字符变量等变量的一种变量类型，为了便于称呼，习惯上直接叫做指针

整型变量存储整型，字符变量存储字符，那么指针变量储存什么呢？

相信，通过上面的两个操作符的例子中，聪明的大家能够猜出来，指针变量储存的是地址。

2、指针的定义方式

这个就不好文字描述了，上代码

    int a = 10;
	int* p = &a;

首先得有对象（现阶段，先假设有对象，后期写代码可能先出指针，后出对象），对这个对象进行取地址，存到指针中。

注意，指针的写法
int 后面还跟了一个*
需要明确的是，这个 星号不是解引用操作符，而是指针的标志

3、稍微拆解一下，方便理解

以这一句代码为例
int * p = &a;

• p是指针变量的名称，

• 星号*则是指针的标志，提示这是一个指针，

• int 则是指针所指向的元素的类型

• 而int *是指针p的类型

当然啦，既然除了整型以外还有字符类型，指针也可以指向除整型以外的其他的数据类型啦

比如下列情况

char a;
char *p1=&a;

short b;
short *p2=&b;

double c;
double *p3=&c;

除此之外还有很多，还可以指向数组，函数等，后面会讲到

4、指针的大小

经过以前的学习，我们知道int 类型是4个字节，char类型是1个字节，short类型是2个字节，float类型是4个字节

那么指针的大小是几个字节呢？

指针的好处来啦！

不用像其他的数据类型一样，记那么多的大小个数

所有类型的指针的大小都是4或8个字节
在32位机器上是4个字节，在64位机器上是8个字节

指针使用来存放地址的，只要是在32位机器下，一个地址由32个0或1组成
共计32个bit，一个字节就是8个bit，所以32位机器下，所有的指针大小都是4个字节，刚好放下一个地址

同理，64位机器同理

5、多种多样的指针存在的意义

既然在同一台机器下，指针的大小都是一样大，而且都是用来存放地址的，那指针要这么多类型干嘛？

这里就要结合我们上面学习到的解引用操作符啦

不同类型的指针在解引用 时可以支配的内存空间的大小是不同的
下面举两个例子看看

a、解引用

#include 
int main()
{
	int a = 0x12345678;
	int* p = &a;
	*p = 0;
	printf("%x\n", a);
	a = 0x12345678;
	char* p2 = (char*)&a;
	*p2 = 0;
	printf("%x\n", a);
	
	return 0;
}

比较代码和运行结果
我们发现int类型的指针可以支配4个字节，而char 类型的指针只能支配一个字节；

b、指针±

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

可以发现int类型的指针+1会跳过4个字节，char类型的指针+1会跳过1个字节，当然其他类型的指针同理
指针减法也是同理

三、丰富的指针世界

1、野指针

野指针呢，听起来还是挺恐怖的，野的，能有多野？

哈哈哈，活跃一下，缓解疲劳
在以后写代码时，当你写出了野指针时，够头疼的了

a、野指针的成因

野指针的成因主要有三个：
1.指针创建的时候没有进行初始化

int *a;
*a=10;

2.指针访问数组时，发生了越界访问，指向了数组以外的空间

int arr[10] = {0};
int *p = &arr[0];
int i = 0;
for(i=0; i<=11; i++)
{
//当指针指向的范围超出数组arr的范围时，p就是野指针
*(p++) = i;
}

数组里下标最大为9，但是for循环，下标却可以到10和11，所以越界访问，形成了野指针

3.指针指向了一个已经释放了的空间，比如函数调用结束了，函数栈帧已经销毁，依然指向这个释放的空间。

#include 
int* test()
{
int n = 100;
return &n;
}
int main()
{
int*p = test();
printf("%d\n", *p);
return 0;
}

在函数test调用结束后，函数栈帧就会销毁，释放内存空间
但是仍然使用了*p指向test，所以形成了野指针

b、如何规避野指针

规避野指针，只需要根据上面三条成因，逐一注意即可
1.定义指针的时候要初始化，玩意没有想好对象，先赋值为NULL空指针
2.注意不要形成数组越界
3.指针使用之前，检查指针是否指向有效空间或对象

c、assert断言

我们在定义指针的时候，常常会使用NULL来初始化，
但是赋值为NULL之后，又很容易忘记已经赋值为NULL了，从而造成报错

这里介绍assert来解决这个问题

int* p = NULL;
	*p = 10;

当写出这样的代码是，编译器就会报错

所以在运用指针前就要进行检查
这里推荐检查方法为assert断言

#include 
#include 
int main()
{
	int* p = NULL;
	assert(p != NULL);
	*p = 10;
	
	return 0;
}

这样如果报错，会提醒在哪个文件，哪一行，从而方便快速寻找错误

注意，assert有头文件
除此之外，assert还有一个好处，就是可以通过定义NDEBUG宏来开启或关闭，
也就是在文件开头加一句#define NDEBUG

又变回了原样子

另外，assert在Windows中，debug版本才起作用，release版本会自动优化掉，不起作用，但是，在Linux操作系统下，debug版本和release版本，assert断言都会起作用

2、指针常量和常量指针

这两个很像的名字，听起来很抽象，哈哈，用起来也很抽象，（当代鲁迅在此qaq）

指针常量和常量指针的成因就在于const修饰的位置不同

a、指针常量

指针常量（pointer to constant）是指指针指向的数据是常量，不能通过指针修改数据的值。声明指针常量时，必须在类型前加上 const 关键字，也就是说const要在*前面

char const* p;
const char* p;

这两种写法都是指针常量，指针指向的对象无法修改

int n = 10;
int m = 20;
const int* p = &n;
*p = 20;//ok?
p = &m; //ok?

*p=20是不可以的，但是p=&m是可以的

b、常量指针

常量指针（constant pointer）是指指针本身是常量，即不能修改指针的指向。声明常量指针时，在指针名前加上 const 关键字，也就是说const放在*后面

int *const ptr;

看一个例子

int n = 10;
int m = 20;
int *const p = &n;
*p = 20; //ok?
p = &m; //ok?

这里*p=20就是可以的，但是p=&m就是不行的

所以，想要确保代码的安全性，最好在*前面后面都加上const，但是实际代码的需求可能要改变变量值，也就不用加const，具体情况具体分析

这才两点，什么，你说你学了好多，哈哈哈，后面还多着呢，指针就是这样，内容很多，需要坚持不懈，一点点啃完

3、二级指针

二级指针和多级指针是一个道理，依次类推就ok啦
这里就只讲解二级指针啦！

我们来思考一个问题，指针存放的是地址对吧，
那么指针本身所占的内存空间的地址用什么储存呢？

这里，就要使用二级指针了

a、二级指针的理解

    int a = 10;
	int* pa = &a;
	int** ppa = &pa;

依据这个图，可以更好的理解二级指针

b、二级指针解引用

通过二级指针也可以直接更改最底层的对象

    int a = 10;
	int* pa = &a;
	int** ppa = &pa;
	(**ppa)++;
	printf("%d\n", **ppa);

4、指针数组和数组指针

分辨指针数组和数组指针的最好方法就是先明确，这是数组还是指针

a、指针数组

（1）数组指针的理解

指针数组本质上还是数组，既然是数组，那么就可以联系整型数组，字符数组等来理解

整型数组是存放整型的数组，字符数组是存放字符的数组，那么指针数组就是存放指针的数组

下面这个图，可以帮助大家更好的理解

（2）指针数组的结构

类似数组
数组有数组名，数组大小，数组存放的类型

同样，指针数组也是如此
以int * parr[5]为例

• parr是数组名
• [5]是数组大小
• int *是存放的元素的类型
• 数组的类型为int * [5]

b、数组指针

（1）数组指针的理解

通过指针数组的学习，运用一样的方法去学习数组指针，事半功倍

首先，数组指针的本质是指针，所以联系整型指针，字符指针去理解

整型指针指向整型变量，字符指针指向字符变量
因此，数组指针指向数组

（2）数组指针的结构

以int (*p)[5]为例

• p是指针变量的名字
• *是提示这是一个指针
• [5]是指p指向一个有五个元素的数组
• int 是指这个数组的元素是int类型
• 数组指针p的类型是int （*） [5]

（3）数组指针的初始化

int arr[5]={1,2,3,4,5};
int (*parr)[5]=&arr;

c、指针数组和数组指针的对比

int * parr[5];
int (*parr)[5];

从形式上看，主要差别在于（）
为什么要括号呢？
*和p一起定义一个指针，
是因为[]的优先级高于（），
所以需要使用括号二者放在一起。
从内容上看，主要一个是数组，一个是指针

5、字符指针

字符指针有一个很神奇的一点，一般来说指针的作用是存储地址，但是根据字符的特殊性，可以使用字符指针打印字符串

存储字符的地址的方法就不讲了，具体讲讲字符指针打印字符串

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

但是，原理是什么呢？又或者说这里是把整个字符串放到指针变量里面了吗？

其实并不是这样

pstr指针里面依然只存放了字符‘h’的地址，但是根据字符串的特性，在内存空间中连续存储，所以会继续往后打印，直到遇到了“\0”为止

注意，这里有几个小细节

1. 注意要打印字符串需要使用%s
2. 不需要使用*操作符
3. 常量字符串不能够修改，比如*pstr='a’就是错误的
4. 这种方法可以处理空格，遇到’\0’才会停下来
5. 如果要打印字符，需要用%c，且加上*操作符

6、函数指针

通过上面的类比学习，我们能够理解，函数指针就是存放函数地址的变量

1、函数的地址

函数也有地址吗？
有没有地址，&取地址一下不就ok了

做个测试看看吧

#include 
void test()
{
     printf("hehe\n");
}

int main()
{
     printf("test: %p\n", test);
     printf("&test: %p\n", &test);
       
     return 0;
}

可以看到，函数的地址&函数名和直接函数名得到的地址是一样的

2、函数指针的写法

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写上或者省略都是可以的

分别示范了两种返回值类型不同的函数的函数指针的写法

3、函数指针类型的结构

以int （*pf3）( int,int )为例

• pf3是函数指针的名称
• *是提示这是一个指针
• （int，int）这是指，指针指向了一个函数，函数有两个参数，都是int类型
• int 是指所指向的这个函数的返回类型是int类型

---

ok ,指针的大体内容基本分享结束，提升对指针的了解，就得靠自己多思考，多敲代码啦

下面，就和大家分享几道有意思的题目

四、分享几道有意思的题目

第一道

(*(void (*)())0)();

这段代码是什么意思呢？

题目还是很有些难度的，仔细思考哦

首先，使用强制转换，将0转换成一个void （*）（）类型的一个函数指针，也就是将0 强制转换成了一个地址，接着对这个地址解引用，再去调用这个0处地址的那个函数

第二道

void (* signal(int, void(*)(int)))(int);

这道题目还是比较有意思的，仔细思考一下

这里是一个函数声明，函数名是signal，有两个参数，一个参数类型是int，另一个参数类型是一个函数指针类型，指向一个函数，这个函数只有一个int类型的参数，返回类型是int
参数说完了，该说返回类型了，返回类型是一个函数指针类型，指向的函数参数只有一个int类型，返回类型为void

---

okk ,今天的分享到这里先结束啦！
！！！！！！！！！谢谢观看！！！！！！！！！
！！！！！！！！记得三连哦！！！！！！！！！