C语言指针【指针】(1)

1.指针与内存的关系

1.1小案例

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

1.一楼：101，102，103……
2.二楼：201，202，203……
……

有了房间号，如果你的朋友得到房间号，就可以快速的找房间，找到你。
其实计算机存储与小案例的原理是一模一样的，我们知道计算机CPU(中央处理器)在处理数据的时候，是要向内存读取需要的数据的，处理之后也会放回内存中(大致关系如下图)。

那我们在买电脑的时候，电脑上的内存是8GB/16GB/32GB等，这些内存是怎样高效处理的呢？
其实也是把内存分为一个一个的内存单元，每个单元的大小为一个字节

补充

计算机最小单位为比特位(bit)，一个比特位可以存储二进制的位0或1，一个字节(byte)能存放八个比特位(关系图如下)

其中每个内存单元就相当于一个学生宿舍，一个字节能放八个比特位，类似于一个八人的宿舍，其中的每一个学生就是一个比特位
每个内存单元都有一个内存编号(这个编号就相当于门牌号)，有了这个"门牌号"，CPU就能快速的找到一个内存空间，在生活中我们会把门牌号称为地址，当然，在计算机中我们也把内存单元的编号称为地址，C语言给地址起了个新名字: 指针
所以我们理解为内存编号 == 地址 == 指针

2.指针变量和地址

2.1 取地址操作符(&)

在C语言创建变量的本质是向内存申请空间
我们怎样才能拿到变量a的地址呢?(&a会取出a所占的4个字节中较小的字节的地址编号)

2.2 指针变量与地址

概念

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

#include<stdio.h>
int main()
{
	int a = 10;
	int* p = &a;//取出a的地址，并将其存放在指针变量p中
	
	return 0;
}

指针变量也是一种变量，这种变量就是用来存放地址的，所以存放在指针变量里的值，都被理解为地址。
指针是地址，指针变量是存放地址的变量(我们口头上说的指针绝大多数都是指针变量)

创建

我们看到p的类型是int*，我们该如何理解指针的类型呢？
p是一个变量(指针变量),是一块空间，*号是在说明p是指针变量(如果没有*，那p就只是一个int类型的变量)，int说明p所指向的对象是int类型的

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

	char ch = 'a';
	pc = &ch;//pc应该是什么类型呢

答案

char* pc = &ch;

解引用操作符

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

代码如下:

#include <stdio.h> 			   //1
int main()          		   //2
{							   //3
	int a = 100;			   //4
	int* pa = &a;			   //5
	*pa = 0;				   //6
							   //7
	printf("*pa = %d\n", *pa); //8
	printf("a  =  %d ", a);	   //9
	return 0;				   //10
}							   //11

上面的第六行就使用解引用操作符，*pa的意思就是通过pa存放的地址，找到pa所指向的内容。其实*pa就是变量a了；所以*pa = 0,这个操作符也把a改为0了。
这里的目的就是把a改成0的话，写成a = 0; 不就完了，为啥非要使用指针呢？
其实这里是把a的修改交给了pa来操作，这样对a的修改，就多了⼀种的途径，写代码就会更加灵活，
后期慢慢就能理解了。

指针变量的大小

32位机器假设有32根地址总线，每个地址线有两态(低电频和高电频；低电频为0，高电频为1)，我们把32跟地址线产生的二进制序列当做一个地址，那么一个地址就有32个bit位，就需要4个字节才能存放；64位机器同理，所以在64位环境下指针变量的大小是8个字节

int main()
{
	//指针变量的⼤⼩取决于地址的⼤⼩

	//32位平台下地址是32个bit位（即4个字节）
	//64位平台下地址是64个bit位（即8个字节）

	printf("%d\n", sizeof(char *));
	printf("%d\n", sizeof(short *));
	printf("%d\n", sizeof(int *));
	printf("%d\n", sizeof(long *));
	printf("%d\n", sizeof(long long *));
	printf("%d\n", sizeof(float *));
	printf("%d\n", sizeof(double *));
	return 0;
}

指针变量的大小和类型无关，只要是指针类型的变量，在同样的环境下，大小都是相同的。

3.指针变量的意义

指针变量的大小和类型无关，只要是指针变量，在同⼀个平台下，⼤⼩都是⼀样的，为什么还要有各种各样的指针类型呢？
其实指针类型是有特殊意义的，我们接下来继续学习。

3.1 指针的解引用

//代码一
int main()
{
	int n = 0x11223344;
	int* p = &n;
	*p = 0;

	return 0;
}
代码二
int main()
{
	int n = 0x11223344;
	char* p = (char*)&n;
	*p = 0;

	return 0;
}

我们进行调试看看这两个代码中内存的变化

调试我们可以看到，代码1会将n的4个字节全部改为0，但是代码2只是将n的第⼀个字节改为0。

结论

指针的类型决定了，对指针解引用的时候有多打的权限（一次能操作几个字节）。
⽐如：char* 的指针解引用就只能访问⼀个字节，而int* 的指针的解引用就能访问四个字节。

3.2指针加减整数

我们先看一段代码，重点看他们地址的变化。

int main()
{
	int a = 100;
	int* pa = &a;
	char* pc = (char*)&a;

	printf("&a   = %p\n", &a);
	printf("pa   = %p\n", pa);
	printf("pa+1 = %p\n", pa+1);
	printf("pc   = %p\n", pc);
	printf("pc+1 = %p\n", pc+1);
	return 0;
}

结果如下

我们可以看出int* 类型的指针加1跳过4个字节，而char*类型的指针加1跳过的是1个字节。

结论

指针类型决定了指针向前走或向后走一步能有多大。

3.3void*指针

在指针类型中void* 一种特殊的指针类型，可以理解为无具体类型的指针(也叫泛型指针)这种类型的指针可以接收任意类型的指针但它也有局限性，void*类型的指针不能进行解引用和加减整数的运算
例

int main()
{
	int a = 0;
	int* pa = &a;
	char* pc = &a;
	return 0;
}

在上面的代码中，我将一个int类型的变量的地址赋给char*类型的指针变量中。在我尝试运行的时候，编译器会发出一个警告(如下图)，这是因为类型不兼容，但void*不会有这个问题

用void*类型的指针来接收地址：

int main()
{
	int a = 0;
	void* pa = &a;
	void* pc = &a;

	*pa = 10;
	*pc = 0;
	pc++;
	return 0;
}

在VS中*pa = 10; *pc = 0; pc++;这三条指令会直接标红线(报错)。
运行结果肯定是不通过的

这里我们能看到，void*类型的指针能接收其他类型的地址，但不能直接对指针进行运算。

那void*类型的指针有什么用呢？

一般void*类型的指针是使用在函数参数的部分，用来接收不同类型的数据的地址，这样的设计可以实现泛型编程的效果，使得⼀个函数来处理多种类型的数据。

4.const修饰指针

4.1const修饰变量

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

int main()
{
	int m = 0;
	m = 100;//可以修改
	const int n = 0;
	n = 10;//经过const修饰后不可修改
	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* pa = &n;
	*pa = 100;
	printf("n = %d\n", n);
	return 0;
}

输出结果：

这里可以看到，n确实被修改了，但是让我们想想，我们为什么要用const修饰n，不就是因为不想n的值被修改吗，如果pa能通过n的地址来修改n，这样就打破了const所带来的语法规则，这很显然是不合理的，所以我们要让pa即使拿到了n的地址也不能修改n的值，这该怎么做呢？

4.2const修饰指针变量

我们可以看下面的代码并进行分析

void test0()
{
	int m = 0;
	int n = 0;
	int* pa = &n;
	*pa = 0;
	pa = &m;
}
void test1()
{
	int m = 0;
	int n = 0;
	int* const pa = &n;
	*pa = 0;
	pa = &m;
}
void test2()
{
	int m = 0;
	int n = 0;
	int const* pa = &n;
	*pa = 0;
	pa = &m;
}
void test3()
{
	int m = 0;
	int n = 0;
	int const * const pa = &n;
	*pa = 0;
	pa = &m;
}
int main()
{
	test0();//指针变量没有const
	test1();//*号右边有const
	test2();//*号左边有const
	test3();//*号左右都有const
	return 0;
}

这时VS会自动标出错误

结论

当const修饰在*号的右边时，const限制的是指针变量本身，指针变量不能再指向其他变量的地址，但可以通过指针变量来改变指针变量本身指向的内容。

当const修饰在*号的左边时，const这次限制的是指针变量所指向的内容，不能通过指针变量来修改被指向的内容，但可以修改指针变量本身的值(也就是修改指针变量的指向)。
const修饰在*号的左右两侧时，这时指针变量既不能修改被指向的内容，也不能修改自身指向的对象。

5.指针运算

5.1 指针±整数

我们知道数组在内存中是连续存放的，所以我们如果知道了第一个元素的地址，就能顺藤摸瓜的找到后面的元素了

//指针+-整数
int main()
{
	int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };
	int* pa = &arr[0];
	int sz = sizeof(arr) / sizeof(arr[0]);

	for (int i = 0; i < sz; i++)
	{
		printf("%d ", *(pa + i));//这就是指针+-整数
	}

	return 0;
}

指针加减多少整数就能跳过多少个自身的类型所占的字节；

type * p; p + 1 ->跳过1*(sizeof(type));

p + n;->跳过n*(sizeof(type))；

5.2指针-指针

模拟实现strlen(求字符串长度)
代码如下：

//指针-指针
int my_strlen(const char* pc)
{
	char* tmp = pc;
	while (*pc != '\0')
	{
		pc++;
	}
	return pc - tmp;//指针-指针
}

int main()
{
	char ch[] = "abcdef";
	int ret = my_strlen(ch);//数组名是首元素的地址
	printf("%d\n", ret);
	return 0;
}

指针-指针得到的是两个指针之间的元素个数(前提是两个指针指向的同一块空间)

5.3指针的关系运算

就是比较指针与指针(地址与地址)之间的大小

//指针的关系运算
int main()
{
	int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };
	int* pa = arr;//数组名是首元素地址
	int i = 0;
	int sz = sizeof(arr) / sizeof(arr[0]);
	while (p < arr + sz) //指针的大小比较
	{
		printf("%d ", *p);
		p++;
	}
	return 0;
}

6.野指针

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

6.1野指针的成因

1.指针未进行初始化

int main()
{
	int* p;//指针未初始化
	*p = 0;
	return 0;
}

2.指针越界访问

int main()
{
	int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };
	int* pa = arr;
	int sz = sizeof(arr) / sizeof(arr[0]);
	for (int i = 0; i <= 11; i++)
	{
		*(pa++) = i;//当指针当指针指向的范围超出数组arr的范围时,pa就是野指针
	}
	return 0;
}

而且在VS中运行会报错

3.指针指向的空间释放

int* test()
{
	int a = 10;
	return &a;//局部变量出了函数，内存空间就销毁了。
}

int main()
{
	int* pa = test();//指针指向的地址已经还给了操作系统
	return 0;
}

相当于你租了一天的酒店房间，这一天这个酒店房间的使用权归你，但过了这一天，这个房间的使用权就还给了酒店，你可以看到这个房间，但已经使用不了了。

6.2如何规避野指针

1.指针初始化

如果你在设立指针的时候明确知道指针该指向哪里，就初始化一个明确的地址，
如果目前还不知道该指向哪里，就给指针赋值一个NULL。

NULL是C语言中定义的一个标识符常量，值为0，0也是地址，但是这个地址是给操作系统用的，我们用户是无法使用的

//NULL的定义
#ifndef NULL
    #ifdef __cplusplus
        #define NULL 0
    #else
        #define NULL ((void *)0)

初始化如下

#include<stdio.h>
int main()
{
	int n = 10;

	int* pn = &n;

	int* pa = NULL;

	return 0;
}

2.小心指针越界

当你向内存申请了哪些空间，那么就限定你的指针只能访问哪些空间，不要超出访问范围，超出了就是越界访问(野指针)

3.当指针变量不在使用时，及时的设置为NULL，在使用指针之前先检查有效性

当指针变量指向一块区域时，我们可以通过访问指针来访问该区域，在后期我们不再使用这个指针来访问空间的时候，我们就及时的设置为NULL。
因为约定俗成的⼀个规则就是：只要是NULL指针就不去访问，同时使⽤指针之前可以判断指针是否为NULL。

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

	if (p != NULL) //判断
	{
		//...
	}
	return 0;
}

4避免返回局部变量的地址

就不要做野指针成因的第三个例子就可以了。

7.assert断言

在使用assert前要包含头文件<assert.h>，其中头文件就定义了宏assert()，用于在运行时确认程序符合指定条件，如果不符合，就直接或报错并终止运行

assert(p != NULL);

上面这个代码在程序运行到这一条时，会验证变量p是否等于NULL。如果确实不等于NULL，代码不会起任何作用,否者就会终止运行，并给出报错信息提示。


assert()是一个对程序员非常友好的代码，它不仅能自动标识文件错问题的行号，还有一种无需增加删减代码就能开启或关闭assert()的机制。在你明确代码没有错误可以轻松关闭assert断言，就在头文件#include <assert.h>语句的前一行，定义一个宏NDEBUG。

#define NDEBUG
#include<stdio.h>

如果程序又出现了问题，就可以注释掉#define NDEBUG指令，再次编译，这样就出现启动了assert()语句。
当然assert也不是完美的
它的缺点就是，因为有了额外的检查，会增加程序运行的时间。
般我们可以在Debug 中使用，在 Release版本中选择禁⽤assert 就行，在VS 这样的集成开发环境，在Release 版本中，直接就是优化掉了。这样在debug版本写有利于程序员排查问题，Release 版本不影响用户使用时程序的效率。

结语

感谢您能阅读完此片文章，如果有任何建议或纠正欢迎在评论区留言。如果您认为这篇文章对您有所收获，点一个小小的赞就是我创作的巨大动力，谢谢！