C语言指针

前言

这一节我们来说指针，指针可以说是C语言最为重要的一个知识点，也是比较难的一个知识点，C语言从1972年问世到现在，还能在当今这么多高级语言中有一席之地可以说是因为指针，所以有一句话是C语言因指针而不朽。当然，本篇博客只是指针的初阶，进阶会在后面，所以本篇不会很难。

什么是指针

在了解指针之前，要先了解内存：内存是存储区域，内存在你买电脑的时候就已经确定了。

如上图，你的电脑也许是4G，8G，16G。我们将内存分成一个个小块，每一块内存都有类似0、1、2的编号，这个编号其实就是内存的地址，而地址又被我们称为指针，所以编号，地址指针其实是一样的。
指针理解的2个要点：

1. 指针是内存中一个最小单元的编号，也就是地址。
2. 平时口语中说的指针，通常指的是指针变量，是用来存放内存地址的变量。

总结：指针就是地址，口语中说的指针通常指的是指针变量。
那我们就可以这样理解内存，如下图：

指针变量的定义：
我们可以通过&（取地址操作符）取出变量的内存起始地址，把地址可以存放到一个变量中，这个
变量就是指针变量。
代码示例如下：

#include 
int main()
{
	int a = 10;//在内存中开辟一块空间
	int* p = &a;//这里我们对变量a，取出它的地址，可以使用&操作符。
	//a变量占用4个字节的空间，这里是将a的4个字节的第一个字节的地址存放在p变量中，p就是一个之指针变量。
	return 0;
}

总结：
指针变量，用来存放地址的变量。（存放在指针中的值都被当成地址处理）。
那这里的问题是：
一个小的单元到底是多大？
答案：1个字节
如何编址？
答案：经过仔细的计算和权衡我们发现一个字节给一个对应的地址是比较合适的。
也就是说，在32位的机器上，地址是32个0或者1组成二进制序列，那地址就得用4个字节的空间来存储，所以
一个指针变量的大小就应该是4个字节。
那如果在64位机器上，如果有64个地址线，那一个指针变量的大小是8个字节，才能存放一个地
址。
总结：
指针变量是用来存放地址的，地址是唯一标示一个内存单元的。
指针的大小在32位平台是4个字节，在64位平台是8个字节。

指针和指针类型

我们都知道，变量有不同的类型，整形，浮点型等。那指针有没有类型呢？
准确的说：有的。
当有这样的代码：

int num = 10;
p = #

要将&num（num的地址）保存到p中，我们知道p就是一个指针变量，那它的类型是怎样的呢？
我们给指针变量相应的类型。

char *pc = NULL;//NULL代表空也就是什么都没有，类似于给一个整形变量赋值为0
int *pi = NULL;
short *ps = NULL;
long *pl = NULL;
float *pf = NULL;
double *pd = NULL;

这里可以看到，指针的定义方式是： type* 。
其实：
char* 类型的指针是为了存放 char 类型变量的地址。
short* 类型的指针是为了存放 short 类型变量的地址。
int* 类型的指针是为了存放 int 类型变量的地址。

指针±整数

这里我们来讲解一下指针类型的意义是什么，代码示例如下：

#include 
int main()
{
	int n = 10;
	char* pc = (char*)&n;//强制类型转换
	int* pi = &n;
	printf("%p\n", &n);//%p是打印地址的意思
	printf("%p\n", pc);
	printf("%p\n", pc + 1);
	printf("%p\n", pi);
	printf("%p\n", pi + 1);
	return 0;
}

如上图可以看出字符类型指针加一后地址变化了一个字节，而整形指针加一后地址变化了4个字节。
总结：指针的类型决定了指针向前或者向后走一步有多大（地址的变化）。

指针的解引用

解引用操作符为*，这里我们直接看图：

如上图可以看到，我们给a赋了一个16进制的数值，在调试过程中我们可以看到，对整形指针解引用时可以访问4个字节的内存，对字符型指针解引用时我们只能访问1个字节的内存。
总结：
指针的类型决定了，对指针解引用的时候有多大的权限（能操作几个字节）。
比如： char* 的指针解引用就只能访问一个字节，而 int* 的指针的解引用就能访问四个字节
另外*也叫取值操作符，这里看代码示例：

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

这里可以看到，若只是输出pi，则是地址，但若加了取值操作符*则会打印出数值。

野指针

概念： 野指针就是指针指向的位置是不可知的（随机的、不正确的、没有明确限制的。也可以说野指针的地址是编译器随机赋的，我们程序猿并不知道。）

野指针成因

1.指针未初始化。

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

如图这种未初始化的野指针在一些编译器上就会报错。
2. 指针越界访问。

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

如上代码数组是十个元素，而指针却访问了11个，这时超出了界限程序虽然没有错误，但运行起来可能会崩溃。

3. 指针指向的空间释放
这涉及到了一些超纲的知识点，在此不过多赘述，这里仅当了解，后续会详细讲解。

如何规避野指针

1. 指针初始化

#include 
int main()
{
	int* p = NULL;//这里就是指针初始化，如果不知道给指针赋什么地址，可以先赋NULL
	int a = 10;
	p = &a;
	if (p != NULL)
	{
		*p = 20;
	}
	return 0;
}

2. 小心指针越界
3. 指针指向空间释放，及时置NULL（释放指针空间要用free()函数，这个后续会讲）
4. 避免返回局部变量的地址

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

如上述代码，我们都知道函数中的变量作用域只在函数内部有效，一旦函数结束就会销毁，这时候我把函数返回的地址赋给指针变量，但函数结束了这个地址就会被销毁，这在一些编译器中可能会造就野指针，所以要避免将局部变量的地址赋给指针变量。
5. 指针使用之前检查有效性。

指针运算

指针±整数

这里直接拿代码举例：

#include 
int main()
{
	int i = 0;
	int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };
	int* p = arr;
	for (i = 0; i < 10; i++)
	{
		printf("%d ",*(p+i));
	}
	return 0;
}

如图，我们可以用指针来打印或改变数组的值。

指针-指针

两个指针相减的前提是：指针指向的同一块连续的空间。

如图，a1，a2是两个数组，p1、p2、p3是指向数组的不同指针，如上图p1和p2可以相减，但p1和p3，p2和p3不能相减，所以指针相减的前提就是指针必须指向同一块连续的空间。代码示例如下：

#include 
int main()
{
	int arr[10] = {0};
	printf("%d\n", &arr[9] - &arr[0]);//指针本质上是地址，所以地址相减也可以代表两指针相减
	printf("%d\n", &arr[0] - &arr[9]);
	return 0;
}

上图所示为指针减指针原理示意图。
那其实我们就可以用指针运算的原理来计算一个字符串的长度了：

#include 
int my_strlen(char* str)
{
	int count = 0;
	while (*str)
	{
	 count++;
		str++;
	}
	return count;
}
int main()
{
	char arr[10] = "abcdef";
	int x = my_strlen(arr);
	printf("%d\n", x);
	return 0;
}

指针的关系运算

其实也是地址之间的关系运算，如比较大小一类：

这里还有一个标准规定：
允许指向数组元素的指针与指向数组最后一个元素后面的那个内存位置的指针比较，但是不允许与
指向第一个元素之前的那个内存位置的指针进行比较。（这个仅当了解，这个标准大多数编译器不会理会，当然能遵守我们最好还是遵守）

指针和数组

这里我们直接看代码：

#include 
int main()
{
	int arr[10] = { 1,2,3,4,5,6,7,8,9,0 };
	printf("%p\n", arr);
	printf("%p\n", &arr[0]);
	return 0;
}

可见数组名和数组首元素的地址是一样的。
结论：数组名表示的是数组首元素的地址。（2种情况除外，数组章节讲解了）

#include 
int main()
{
	int i;
	int arr[] = { 1,2,3,4,5,6,7,8,9,0 };
	int* p = arr; //指针存放数组首元素的地址
	int sz = sizeof(arr) / sizeof(arr[0]);
	for (i = 0; i < sz; i++)
	{
		printf("&arr[%d] = %p <====> p+%d = %p\n", i, &arr[i], i, p + i);
	}
	return 0;
}

所以 p+i 其实计算的是数组 arr 下标为i的地址。
那我们就可以直接通过指针来访问数组

#include 
int main()
{
	int arr[] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 0 };
	int* p = arr; //指针存放数组首元素的地址
	int sz = sizeof(arr) / sizeof(arr[0]);
	int i = 0;
	for (i = 0; i < sz; i++)
	{
		printf("%d ", *(p + i));
	}
	return 0;
}

二级指针

指针变量也是变量，是变量就有地址，那指针变量的地址存放在哪里？
这就是 二级指针

如上图a的地址是0x0019fdc4，a的地址赋给了指针变量p，一级指针p自身的地址是0x0019fdb8，这时候再=将p的地址赋给二级指针pp，这里若我们调用*pp那么解引用得到的是a的地址，若用**pp那么双重解引用得到的是a的值。（这里说一下，*代表变量是指针类型，int和int *代表p指向整形变量和pp指向整形指针变量）


以上两幅图是一起的。

指针数组

指针数组是指针还是数组？
答案：是数组。是存放指针的数组。
那么指针数组是什么样子的？
指针数组代码示例如下：

int* arr3[5];//指针数组示例

那指针数组有什么用？
答案：我们可以用指针数组实现一维数组二维化。

#include 
int main()
{
	//用一维数组模拟一个二维数组
	int arr1[] = { 1,2,3,4,5 };
	int arr2[] = { 2,3,4,5,6 };
	int arr3[] = { 3,4,5,6,7 };
	int arr4[] = { 4,5,6,7,8 };

	int* arr[4] = {arr1, arr2, arr3, arr4};
	int i = 0;
	for (i = 0; i < 4; i++)
	{
		int j = 0;
		for (j = 0; j < 5; j++)
		{
			printf("%d ", arr[i][j]);
		}
		printf("\n");
	}
	
		return 0;
}

这个程序我们只解释一下这一行代码arr[i][j]我们设i=2，j=3时，这里指针数组存的时每个一维数组的地址arr[2]相当于取出了arr3数组，又因为j=3，所以arr[2][3]就等价于arr3[3],打印数字就是6。
最后期待您的三连，如有错误，欢迎私信或在评论区指正。