指针没那么可怕之初阶指针（简单易懂）

前言

想必大多数人在接触指针之前，都觉得指针比较困难，但接触之后也没有想象中的那么难，所以我们不要把问题给想复杂了。
指针就是地址，我可以通过指针变量存放的地址找到相应的元素
比如：我们想找到小明，我们是不是通过地址找更容易，更快一些。

创作不易，留下你的小心心再走吧

1.指针是什么

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

在内存中，每个字节都有自己的单元编号

指针变量

我们可以通过&（取地址操作符）取出变量的内存起始地址，把地址可以存放到一个变量中，这个变量就是指针变量

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

指针变量，用来存放地址的变量。（存放在指针中的值都被当成地址处理）

对于32位的机器，假设有32根地址线，那么假设每根地址线在寻址的时候产生高电平（高电压）和低电平（低电压）就是（1或者0）

那么32根地址线产生的地址就会是：

00000000 00000000 00000000 00000000
00000000 00000000 00000000 00000001
…
11111111 11111111 11111111 11111111

这里就有2的32次方个地址

每个地址标识一个字节，那我们就可以给 （2^32Byte =2^32/1024KB =
2^{32/1024/1024MB==2}32/1024/1024/1024GB =4GB） 4G的空间进行编址（64位机器则是2^64个地址）

在32位机器上，一个指针变量的大小就是4个字节
在64位机器上，一个指针大小是8个字节

2.指针和指针类型

这里我们在讨论一下：指针的类型
我们都知道，变量有不同的类型，整形，浮点型等。那指针有没有类型呢？
准确的说：有的。

char  *pc = NULL;
int   *pi = NULL;
short *ps = NULL;
long  *pl = NULL;
float *pf = NULL;
double *pd = NULL;

32位机器为例：
既然指针都是4个字节，那指针类型存在的意义又是什么呢？

	
#include <stdio.h>

int main()
{
	int n = 10;
	char* pc = (char*)&n;
	int* pi = &n;

	printf("%p\n", pc);//char类型的指针
	printf("%p\n", pc + 1);
	printf("%p\n", pi);//int类型的指针
	printf("%p\n", pi + 1);
	return  0;
}

运行结果：

我们可以清楚的看到：
char类型的指针+1是跳过了1个字节的位置
int类型的指针+1是跳过了4个字节的位置

由此可见指针类型之前的区别
总结：指针的类型决定了指针向前或者向后走一步有多大（距离）

2.1指针的解引用

#include <stdio.h>
int main()
{
	int n = 0x11223344;//0x是以16进制表示
	char* pc = (char*)&n;//把int类型的变量地址放到char类型的指针
	int* pi = &n;
	*pc = 0;   //重点在调试的过程中观察内存的变化。
	*pi = 0;   
	return 0;
}

我们先看把int类型的变量地址放到char类型指针变量里，然后解引用*pc赋值0的内存变化。
我们可以清楚的看到，只改变了一个字节的内存

再看int类型指针变量赋值，改变了4个字节的内容

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

3.野指针

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

看代码可以更清楚的理解：

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

指针越界访问：

#include <stdio.h>

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

指针指向的空间释放：

这里我们用int* p来接收Test()函数返回来的指针，我们在函数内部创建了n返回n的地址，当出了函数，函数内存就会释放，主函数里*p所指向的空间就是不可控的

int* Test()
{
	int n = 10;
	return &n;
}

int main()
{
	int* p = Test();
	printf("%d\n", *p);
	return 0;
}

以上代码我们都称之为野指针，比较危险，不可控。

如何规避野指针：
1 指针初始化
2.小心指针越界
3.指针指向空间释放，及时置NULL
4.避免返回局部变量的地址
5.指针使用之前检查有效性

4.指针运算

指针±整数
把数组values[0]第一个元素地址放到vp指针变量里，此时此刻*vp指向数组第一个元素，然后赋值为0，再自增1，*vp指向数组第二个元素，以此类推，循环5次。

#define N_VALUES 5
int main()
{
	float values[N_VALUES];
	float *vp;
	//指针+-整数；指针的关系运算
	for (vp = &values[0]; vp < &values[N_VALUES];)
	{
     	*vp++ = 0;
	}
}

指针-指针：

指针-指针得到的是两个指针元素之间的个数

我们用指针-指针的方法来写一个求字符串长度的函数：

int my_strlen(char* arr)
{
	char* start = arr;
	while (*arr != '\0');
	{
		arr++;
	}
	return arr-start;//返回两个指针之间元素的个数
}

int main()
{
	char arr[] = "abcdef";
	int len = my_strlen(arr);
	printf("%d\n", len);
	return 0;
}

指针的关系运算：

for(vp = &values[N_VALUES]; vp > &values[0];)
{
    *--vp = 0;
}

我们将代码简化一下：

for(vp = &values[N_VALUES-1]; vp >= &values[0];vp--)
{
    *vp = 0;
}

标准规定：
允许向数组最后一个元素后面的那个内存位置的指针比较，但是不允许与指向第一个元素之前的那个内存位置的指针进行比较

5.指针和数组

我们知道数组名就是首元素的地址
两种情况除外：
sizeof（数组名），这里的数组名是表示整个数组，计算的是整个数组的大小，单位是字节。
&(数组名)，取出的是整个数组的大小
注：
指针是指针，数组是数组，只能说它们俩之间有一定的联系
数组开辟一块空间，指针可以通过首元素地址进行一系列的访问和操作

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;
}

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

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

运行结果：

6.二级指针

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

如下：

int main()
{
	int a = 10;

	int* pa = &a;

	int** ppa = &pa;//ppa就是二级指针变量

	return 0;
}

当然，我们也可以通过解引用访问
当拿到ppa的时候，解引用就能找到pa，从而就能找到a
**ppa – *pa – a

#include <stdio.h>

int main()
{
	int a = 10;
	int* pa = &a;
	int** ppa = &pa;

	printf("%d\n", **ppa);

	return 0;
}

结果打印的当然就是a里面放的值，不信可以去试试啦

7.指针数组

指针数组 – 存放指针的数组
指针数组是数组？还是指针？
答案是：是数组

显而易见： char arr[5] - 存放的是字符数组
int arr[5] - 存放的是整形数组

假设我们有一组变量，那我们能不能把变量的地址存起来呢？

例如：

这里就是指针数组的概念

int main()
{
	int a = 10;
	int b = 20;
	int c = 30;
	int d = 40;
	int e = 50;
	int* arr[5] = { &a, &b, &c, &d, &e };

	return 0;
}

上面只是一种概念，可以更直观的了解指针数组
可能会用到的应用场景：
怎么用一维数组模拟出一个三行四列的数组？？

int main()
{
	int a[] = { 1,2,3,4 };
	int b[] = { 5,6,7,8, };
	int c[] = { 8,9,10,11 };
	int* arr[] = { a, b, c };
	int i = 0;
	for (i = 0; i < 3; i++)
	{
		int j = 0;
		for (j = 0; j < 4; j++)
		{
			printf("%d ", arr[i][j]);
		}
		printf("\n");
	}
	return 0;
}

想必看到这，大家对指针有了一定的了解吧