前言

本篇博客主要是初始指针，简单使用指针，在日常的使用解决问题中运用指针。

(文末福利不要错过！！)

一. 指针是什么？

指针:是内存单元的编号，也就是指针。

指针理解的 2 个要点：

1. 指针是内存中一个最小单元的编号，也就是地址

2. 平时口语中说的指针，通常指的是指针变量，是用来存放内存地址的变量

总结：指针就是地址，口语中说的指针通常指的是指针变量。

所以我们可以理解为：内存

内存单元 - 编号 - 地址 - 指针
 平时口语中的指针是指针变量，是存放内存变量的
 
 内存被划分为一个个小的内存单元  一个基本的内存单元的大小是一个字节
 地址： 内存单元的编号 0X00000000
 内存单元编号的产生： 32位机器-32跟地址线-物理的电线- 通电-1/0
                   00000000 00000000 00000000 00000000 -- 4个字节
                   00000000 00000000 00000000 00000001
                   00000000 00000000 00000000 00000010
                   ....     ...      ...      ...
                   11111111  11111111 11111111 11111111
                   2*10^32 bite   -- 4GB
 64位

指针变量

我们可以通过 & （取地址操作符）取出变量的内存其实地址，把地址可以存放到一个变量中，这个

变量就是指针变量

int main()
{
	int a = 10;// 四个字节
 
	int* pa = &a;//pa存的是地址 所以pa就是指针变量
	printf("%d\n", sizeof(pa));
	printf("%p", &a);
	return 0;
}

下面这张图可便于大家理解：

添加图片注释，不超过 140 字（可选）

举例：

int main()
{
	int a = 0x11223344;
	int* pa = &a;
	*pa = 0;
	//char* pc = &a;
	//*pc = 0;
	//int*   --> 4
	//char*   --> 1
	//double*   --> 8
 
	return 0;
}

地址的打印：

添加图片注释，不超过 140 字（可选）

二. 指针和指针类型

这里我们在讨论一下：指针的类型

我们都知道，变量有不同的类型，整形，浮点型等。那指针有没有类型呢？

准确的说：有的。

int main()
{
	int a = 10;
	int* pa = &a;//整形  --4 
 	char* pc = &a;//字符 --1
	printf("%p\n", pa);
	printf("%p\n", pa+1);
 
	printf("%p\n", pc);
	printf("%p\n", pc+1);
 
	//指针类型决定了指针向前或者向后走一步走的距离 -- 单位是字节
	return 0;
}

指针类型决定了指针向前或者向后走一步走的距离 -- 单位是字节

指针的定义方式是： type + * 。

其实：

char* 类型的指针是为了存放 char 类型变量的地址。

short* 类型的指针是为了存放 short 类型变量的地址。

int* 类型的指针是为了存放 int 类型变量的地址。

添加图片注释，不超过 140 字（可选）

2.1 指针的解引用

添加图片注释，不超过 140 字（可选）

添加图片注释，不超过 140 字（可选）

总结：

指针的类型决定了，对指针解引用的时候有多大的权限（能操作几个字节）。

比如： char* 的指针解引用就只能访问一个字节，而 int* 的指针的解引用就能访问四个字节。

2.2 指针+-整数

添加图片注释，不超过 140 字（可选）

添加图片注释，不超过 140 字（可选）

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

举例：

添加图片注释，不超过 140 字（可选）

分析：

添加图片注释，不超过 140 字（可选）

int main()
{
	int arr[10] = { 0 };
	int* p = arr;
	int i = 0;
	for (i = 0; i < 10; i++)
	{
		//正着初始化
		*(p+i) = i+1;
	}
	//正着打印
	int* m = &arr[0];
	for (i = 0; i < 10; i++)
	{
		printf("%d ", *m);
		m++;
	}
	printf("\n");
	//倒着打印  9 8 7 ...
	int* q = &arr[9];
	for (i = 0; i < 10; i++)
	{
		printf("%d ", *q);
		q--;
	}
	return 0;
}

演示分析：

添加图片注释，不超过 140 字（可选）

添加图片注释，不超过 140 字（可选）

三. 野指针

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

3.1野指针成因

1. 指针未初始化

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

2. 指针越界访问

        int arr[10] = { 0 };
	int* p = arr;
	for (int i = 0; i <= 10; i++)
	{
		*p = i;
		p++;
	}

添加图片注释，不超过 140 字（可选）

3. 指针指向的空间释放

//指针指向的空间释放
 
int* test()
{
	int a = 100;
	return &a;
}
int main()
{
	int* p = test();
	printf("%d", *p);
	return 0;
}
 
int main()
{
	int a = 10;
	int* pa = &a;// 知道存给谁
 
	int* p = NULL;//初始化成空指针
	if (p != NULL)
	{
 
	}
 
	return 0;
}

分析：

添加图片注释，不超过 140 字（可选）

3.2 如何规避野指针

添加图片注释，不超过 140 字（可选）

四. 指针运算

4.1指针+-整数

初始化并赋值打印
int main()
{
	int arr[10] = { 0 };
	int* p = arr;
	int i = 0;
	int sz = sizeof(arr) / sizeof(arr[0]);
	for (i = 0; i < sz; i++)
	{
		*(p + i) = i+1;
	}
	//打印
	for (i = 0; i < sz; i++)
	{
		printf("%d ", *(p + i));
	}
	return 0;
}

4.2指针-指针

int main()
{
	/*int a[10] = { 0 };
	
	printf("%d\n", &a[9] - &a[0]);
	printf("%d\n", &a[0] - &a[9]);*/
 
	int a = 10;
	char c = 'w';
 
 
	return 0;
}

添加图片注释，不超过 140 字（可选）

添加图片注释，不超过 140 字（可选）

举例2：求字符串的长度

在之前我们用strlen函数写了可以求字符串的长度

//求字符串长度的函数 strlen
#include <string.h>
 
int My_strlen(char* s)
{
	int count = 0;
	while(*s != '\0')
	{
		count++;
		s++;
	}
	return count;
 
}
int main()
{
	char arr[] = "abc";
	int len =My_strlen(arr);
 
	printf("%d\n", len);
	
	return 0;
}

同样我们也可以使用指针减指针的方法

int My_strlen(char* s)
{
 
	char* start = s;
	while (*s != '\0')
	{
		s++;
	}
	return  s - start;
}
int main()
{
	char arr[] = "abc";
	int len =My_strlen(arr);
 
	printf("%d\n", len);
	
	return 0;
}

分析：

添加图片注释，不超过 140 字（可选）

4.3指针的关系运算

int main()
{
	float a[5];
	float* p;
	for (p = &a[5]; p >= &a[0];)
	{
		*--p = 0;
	}
	return 0;
}

添加图片注释，不超过 140 字（可选）

添加图片注释，不超过 140 字（可选）

改进：

	for (p = &a[4]; p >= &a[0]; p--)
	{
		*p = 0;
	}

添加图片注释，不超过 140 字（可选）

标准规定：

允许指向数组元素的指针与指向数组最后一个元素后面的那个内存位置的指针比较，但是不允许与

指向第一个元素之前的那个内存位置的指针进行比较。

添加图片注释，不超过 140 字（可选）

五. 指针和数组

 指针 -- 地址
 数组 -- 一组相同类型的数据
int main()
{
	int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };
	//arr首元素地址
	int* p = arr;
	int i = 0;
	for (i = 0; i < sizeof(arr) / sizeof(arr[0]); i++)
	{
		printf("%p == %p \n", p + i,&arr[i]);
	}
 
 
	return 0;
}

分析：

添加图片注释，不超过 140 字（可选）

添加图片注释，不超过 140 字（可选）

可见数组名和数组首元素的地址是一样的。

结论： 数组名表示的是数组首元素的地址 。

那么这样写代码是可行的：

int arr [ 10 ] = { 1 , 2 , 3 , 4 , 5 , 6 , 7 , 8 , 9 , 0 };

int * p = arr ; //p 存放的是数组首元素的地址

既然可以把数组名当成地址存放到一个指针中，我们使用指针来访问一个就成为可能。

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("&arr[%d] = %p   <====> p+%d = %p\n", i, &arr[i], i, p + i);
	}
	return 0;
}

添加图片注释，不超过 140 字（可选）

所以p+i其实计算的是数组arr下标为i的地址

六. 二级指针

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

这就是 二级指针 。

int main()
{
	int a = 10;
	int* pa = &a;
	int** ppa = &pa; //ppa就是一个二级指针
	**ppa = 20;
	printf("%d\n",a);
 
	return 0;
}

添加图片注释，不超过 140 字（可选）

添加图片注释，不超过 140 字（可选）

七. 指针数组

指针数组是指针还是数组？

答案：是数组。是存放指针的数组。

数组我们已经知道整形数组，字符数组。

int main()
{
	int arr[10];//整形数组
	char ch[5];//字符数组
 
	//指针数组 --- 存放指针的数组
	int a = 10;
	int b = 20;
	int c = 30;
	int* arr2[5] = {&a,&b,&c};//存放整形指针的数组
	int i = 0;
	for (i = 0; i < 3; i++)
	{
		printf("%d ", *(arr2[i]));
	}
	return 0;
}

添加图片注释，不超过 140 字（可选）

添加图片注释，不超过 140 字（可选）

总结

本篇文章大致总结了指针在日常学习中的简单使用，如果看完对大家有所帮助的话，希望大家点赞收藏+关注，感谢各位大佬们的支持，另外分享一个宝藏C/C++Linux进阶课程的免费公开课，有兴趣的伙伴可以点击下方免费报名开始学习：C/C++Linux服务器开发/后台架构师【零声教育】-学习视频教程-腾讯课堂