【C】指针详解（一篇文章带你玩转指针）

很多人学习C语言都在为指针头疼，今天一篇文章带你玩转指针。

指针是什么？

在计算机科学中，指针（Pointer）是编程语言中的一个对象，利用地址，它的值直接指向（points to）存在电脑存储器中另一个地方的值。由于通过地址能找到所需的变量单元，可以说，地址指向该变量单元。因此，将地址形象化的称为“指针”。意思是通过它能找到以它为地址的内存单元。
我们前辈综合考虑，将一个内存单元的大小定义为一个字节。
每一个内存单元都对应一个编号，我们通过这个编号就可以找到这块内存，那么编号是怎么产生的呢？
编号是有电子信号产生的，我们32位机器下就有32根地址线，64位机器下就有64根地址线，我们以32位机器举例，每一根地址线能产生0/1二进制数字，所以32根地址线就有2的32次方种编号，也就是2的32次方个字节的内存，4个GB的内存。而要将这32个比特位存储起来，就需要4个字节的内存，所以在32位机器下，不管什么指针大小都是4个字节。以此类推，那如果在64位机器上，如果有64个地址线，那一个指针变量的大小是8个字节，才能存放一个地址。
总结一下：

指针是用来存放地址的，地址是唯一标示一块地址空间的。
指针的大小在32位平台是4个字节，在64位平台是8个字节。

指针和指针类型

指针是有类型的，整型数据的地址要放到整型指针中，字符的地址要放到字符指针中。那么都有哪些指针类型呢？

在这里我们可以看到定义一个指针的方法就是

类型名* 名称

指针的大小在相同的平台下都是相同的，那么指针类型有什么用呢？

指针加减整数

代码演示：

#include <stdio.h>

int main()
{
    
    
	 int n = 10;
	 char *pc = (char*)&n;
	 int *pi = &n;
	 
	 printf("%p\n", &n);
	 printf("%p\n", pc);
	 printf("%p\n", pc+1);
	 printf("%p\n", pi);
	 printf("%p\n", pi+1);
	 return  0;
}

运行结果：

这里的地址都是16进制表示的，我们可以看到pc加一跳过了1个字节，pi加一跳过了4个字节，所以指针类型就决定了指针加减整数跳过的字节数。
总结：

指针的类型决定了指针向前或者向后走一步有多大（距离）。

指针的解引用

解引用就是通用过指针来访问指向的内容，只需要在指针变量前加*就可以了。
代码演示：

#include <stdio.h>

int main()
{
    
    
	 int n = 0x11223344;
	 char *pc = (char *)&n;
	 int *pi = &n;
	 *pc = 0;   
	 *pi = 0;   
	
	 return 0;
}

当执行完*pc = 0后，n变为了

执行完pi = 0后，n变为了

我们可以看到不同的指针类型解引用访问的字节数也是不相同的。
总结

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

野指针

概念： 野指针就是指针指向的位置是不可知的（随机的、不正确的、没有明确限制的）指针变量在定义时如果未初始化，其值是随机的，指针变量的值是别的变量的地址，意味着指针指向了一个地址是不确定的变量，此时去解引用就是去访问了一个不确定的地址，所以结果是不可知的。
野指针非常的危险，它指向了不确定的空间，会非法的访问内存。

野指针的成因

1.指针未初始化
2.指针的越界访问
3.指针指向的空间被释放

如何规避野指针

1. 指针初始化（不确定的先初始化为NULL）
2. 小心指针越界
3. 指针指向空间释放即使置NULL
4. 指针使用之前检查有效性

指针和数组的关系

数组名是什么？

我们看下面代码

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

运行结果：

我们可以看到，数组名就是首元素的地址。那么我们就可以讲数组名放到一个指针中，就可以通过这个指针来访问这个数组。
例如：

#include <stdio.h>
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))// 这里的*(p+i)==p[i]
	 }
	 return 0;
}

二级指针

二级指针是什么？

指针变量也是变量，是变量就有地址，二级指针就是来存放指针变量的地址的。

二级指针的运算

这里的ppa就是一个二级指针。
*ppa 通过对ppa中的地址进行解引用，这样找到的是 pa ， *ppa 其实访问的就是 pa .
**ppa 先通过 *ppa 找到 pa ,然后对 pa 进行解引用操作： *pa ，那找到的是 a .

字符指针

字符指针是char*，我们一般是用它来存放字符的地址的。但是还有一种用法：

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

这里是将这个字符串的首字符的地址放到pstr中去了。
我们看下面的一段代码：

#include <stdio.h>

int main()
{
    
    
	char str1[] = "hello world.";
	char str2[] = "hello world.";
	char* str3 = "hello world.";
	char* str4 = "hello world.";
	if (str1 == str2)
		printf("str1 and str2 are same\n");
	else

		printf("str1 and str2 are not same\n");

	if (str3 == str4)
		printf("str3 and str4 are same\n");
	else

		printf("str3 and str4 are not same\n");

	return 0;
}

我们先来分析一下，我们开辟了两个数组，这两个数组中存放的内容是一样的，但是这两个数组的地址肯定不一样，所以第一个肯定是not same，后面的指针变量，指向的都是"hello world."的首元素h的地址，所以他俩肯定一样的，所以第二个肯定是same。我们来看一下结果：

果然，答案和我们想的一样。

指针数组和数组指针

指针数组

指针数组顾名思义，肯定是一个数组，但是数组里面的每个元素都是指针，例如：

int* arr1[10]; //整形指针的数组

char *arr2[4]; //一级字符指针的数组

char **arr3[5];//二级字符指针的数组

我们这里可以利用指针数组模拟一个二维数组：

#include <stdio.h>

int main()
{
    
    
	int arr1[] = {
    
     1,2,3,4,5 };
	int arr2[] = {
    
     2,3,4,5,6 };
	int arr3[] = {
    
     3,4,5,6,7 };
	int* Arr[] = {
    
     arr1,arr2,arr3 };
	return 0;
}

这里的Arr就类似于一个二维数组，但是二维数组的数据是连续存放的，这里的arr1，与arr2是不连续的。

数组名和&数组名

我们先看下面一段代码：

#include <stdio.h>

int main()
{
    
    
	 int arr[10] = {
    
     0 };
	 printf("arr = %p\n", arr);
	 printf("&arr= %p\n", &arr);
	 printf("arr+1 = %p\n", arr+1);
	 printf("&arr+1= %p\n", &arr+1);
	 return 0;
}

运行结果：

在这里我们可以看到，数组名和&数组名表示的地址相同，都是首元素的地址，但是数组名加一跳过的是一个该元素类型的大小，而&数组名跳过的是整个数组的大小，这就是他们的区别。

数组指针

数组指针顾名思义就是指针了。它指向的是整个数组，存放的是数组的地址。

int (p2)[10];（p2就是一个数组指针）
[]的优先级要高于号的，所以必须加上（）来保证p先和结合。
p先和结合，说明p是一个指针变量，然后指着指向的是一个大小为10个整型的数组。所以p是一个
指针，指向一个数组，叫数组指针。

数组指针的使用

数组指针一般使用与二维数组传参的时候，例如：

#include <stdio.h>

void print(int(*p)[5], int x, int y) //这里的int(*p)[5] 也可以写成int p[][5]
{
    
    
	for (int i = 0; i < x; i++)
	{
    
    
		for (int j = 0; j < y; j++)
		{
    
    
			printf("%d ", p[i][j]);
		}
		printf("\n");
	}
}
int main()
{
    
    
	int arr[3][5] = {
    
     0 };
	print(arr,3,5);
	return 0;
}

我们这里传参传的是arr，arr是一个二维数组，首元素就是一个int [5]的一个数组，它的地址就需要用数组指针来接收。

函数指针和函数指针数组

函数指针

函数指针也是一个指针，它是指向函数的，函数也是有地址的，函数指针就是来存放函数的地址的。
我们看下面一段代码：

#include <stdio.h>

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

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

运行结果：

我们可以看到函数名和&函数名都是该函数的地址。
那么函数指针该怎么表达呢？

void (pfun1) ();
pfun1先和结合，说明pfun1是指针，指针指向的是一个函数，指向的函数无参数，返回值类型为void。

我们只要知道了函数的返回类型，以及参数，就可以创建函数指针了。

函数指针数组

要把函数的地址存到一个数组中，那这个数组就叫函数指针数组，那函数指针的数组如何定义呢？

int (parr1[10]])();
parr1 先和 [] 结合，说明parr1是数组，数组的内容是什么呢？ 是 int ()() 类型的
函数指针。

函数指针的用途：转移表

今天的分享就到这里了，感谢大家的关注和支持！