引言
思绪很久，还是决定写一写指针，指针这块内容很多，也不是那么容易说清楚，这里尽可能写地详细，让大家理解指针。（未完序）
一、内存和地址
在讲指针前，需要有一个对内存和地址的认识，不然后面的指针不是那么容易理解。在我们的内存中：一个字节里存储着 0 或 1 的信息。那计算机是怎么快速找到对应的信息的呢？
回答：在内存中每个字节都有自己对应的地址，计算机通过找到地址，就能访问地址里面的信息。
那么指针，就是一种可以存储地址的数据类型。
二、一级指针
1.存地址：
重点：其实指针是很简单的，只要会使用int ，float， double，long long 等数据类型，那么指针变量，你也一定会使用。
先介绍一下指针变量是怎么创建的：
在对应数据类型的后面加上*，就可以存储该类型的内存地址。
认识个东西 ： & 取地址操作符，看下面的代码：
cppint b = 10; int* a = &b;这段代码创建了一个变量b，&b，就可以取出b的地址。
int* 就是int类型的指针变量，a 里面存的就是 b 的地址
通过调试来看一下：
可以看到 b 的地址
下面通过监视窗口，看一下a里面存的是什么：
发现就是b的地址。
类似地，如果要存float数据类型的地址，就要创建float类型的指针变量：
cppfloat c = 1.2; float* d = &c;d中存储的就是 c 的地址。
其他的数据类型一样，包括自定义类型的数据。
可以自己多试试。
2.解读地址对应的内容：
要用到一个东西：解引用操作符：*
使用起来也特别简单：
比如上面代码中，a中存储的是b的地址，*a，就可以找到b对应位置的内容了
来看代码：
cpp#include<stdio.h> int main() { int b = 10; int* a = &b; int c = *a; //*a 等价于 b printf("%d\n", c); *a = 20; //改变a地址里面的内容，就是把b的内容给改了 printf("%d\n", b); return 0; }运行结果：
是不是特别简单，认为指针难，是因为你不理解每个符号的内容，这里给拆开来讲，相信你一定明白了
3.指针变量的大小
int在内存中占4个字节，float在内存中占4个字节，double在内存中占8个字节，和int，float，double等类型一样，指针类型在内存中也是占有字节的。
那指针类型在内存中占多少个字节呢？
先给出结论，下面来看代码证明。
• 32位平台下地址是32个bit位，指针变量大小是4个字节
• 64位平台下地址是64个bit位，指针变量大小是8个字节
• 注意指针变量的大小和类型是无关的，只要指针类型的变量，在相同的平台下，大小都是相同的。（和CPU里面的线路有一定的关系）
sizeof操作符同样可以返回指针类型在内存中占多少个字节。
cpp
#include<stdio.h>
int main()
{
printf("%zd\n", sizeof(char*));
printf("%zd\n", sizeof(short*));
printf("%zd\n", sizeof(int*));
printf("%zd\n", sizeof(double*));
return 0;
}在不同平台下运行这段代码：
在32位平台下：
运行结果： 
在64位平台下：
运行结果：
三、指针变量类型的意义
你是不是会有这么个疑问：
指针变量的大小和类型无关，只要是指针变量，在同一个平台下，大小都是一样的，为什么还要有各种各样的指针类型呢？
其实指针类型是有特殊意义的，通过两中方法来理解一下。
1.指针的解引用
下面看两段代码：
cpp//代码1 #include <stdio.h> int main() { int n = 0x11223344; int* pi = &n; *pi = 0; return 0; }
cpp//代码2 #include <stdio.h> int main() { int n = 0x11223344; char* pc = (char*)&n; *pc = 0; return 0; }代码二中给int*类型，强制转换成了char*类型。最后都解引用后赋值0
通过调试，来看一下两段代码在内存中的存储。
代码一：
代码二：
相信聪明的你一定发现了不同，代码1会将n的4个字节全部改为0，但是代码2只是将n的第一个字节改为0。
得出结论：指针的类型决定了，对指针解引用的时候有多大的权限（一次能操作几个字节）。 比如： char* 的指针解引用就只能访问⼀个字节，而 int* 的指针的解引用就能访问四个字节。
2.指针+ -整数
有了上面的结论，这个就很容易理解了
来看代码：
cpp
#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;
}来看运行结果：
char* 类型的指针变量+1跳过1个字节， int* 类型的指针变量+1跳过了4个字节。 这就是指针变量的类型差异带来的变化。指针+1，其实跳过1个指针指向的元素。指针可以+1，也可以-1。
结论：指针的类型决定了指针向前或者向后走一步有多大（距离）。
四、void* 指针
在指针类型中有⼀种特殊的类型是 void * 类型的，可以理解为无具体类型的指针（或者叫泛型指针），这种类型的指针可以用来接受任意类型地址。但是也有局限性， void* 类型的指针不能直接进行指针的+-整数和解引用的运算。
来看代码：
cpp
#include <stdio.h>
int main()
{
int a = 10;
int* pa = &a;
char* pc = &a;
return 0;
}这段代码在编译的时候肯定是会报警告的。（因为类型不兼容）
cpp
#include <stdio.h>
int main()
{
int a = 10;
void* pa = &a;
void* pc = &a;
//*pa = 10; 这样写是错误的
//*pc = 0;
return 0;
}void* 类型的指针可以接收不同类型的地址，但是无法直接进行指针运算。
一般 void* 类型的指针是使用在函数参数的部分，用来接收不同类型数据的地址，这样的设计可以实现泛型编程的效果。
五、指针运算
1.指针+-整数
上面的一个代码已经可以看出这个功能了，这里再通过一个案例来理解一下（也算是一个小的练习）
通过地址来访问一个数组。
cpp
#include<stdio.h>
int main()
{
int arr[10] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
int* p = &arr[0]; //取出首元素的地址
int i = 0;
int sz = sizeof(arr)/sizeof(arr[0]);
for (int i = 0; i < sz; i++)
{
printf("%d ", *(p + i));
}
return 0;
}运行结果：
从这个案例中可以看出：*(p + i) 等价于 p[i]。（其实就是这样）
这也可以说明数组名是就是数组首元素的地址。
不过有来个特例需要记一下：
1. &arr，对数组名取地址，得到的是整个数组的地址，而不是首元素的地址。
2. sizeof(arr)，这里面的arr也是整个数组的地址，而不是首元素的地址。
把上面代码改一下来证明一下：
cpp
#include<stdio.h>
int main()
{
int arr[10] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
int* p = &arr[0]; //取出首元素的地址
int i = 0;
int sz = sizeof(arr)/sizeof(arr[0]);
for (int i = 0; i < sz; i++)
{
//printf("%d ", *(p + i));
printf("%d ", p[i]);
}
return 0;
}只改了一个地方，就是输出位置。
运行结果： 
是不是又增加了新知识，嘿嘿(●ˇ∀ˇ●)
2.指针-指针
后面位置的指针减前面位置的指针，可以计算出两个指针之间字节个数。
来看参考代码：
cpp
#include <stdio.h>
int my_strlen(char* s)
{
char* p = s;
while (*p != '\0')
p++;
return p - s;
}
int main()
{
printf("%d\n", my_strlen("abc"));
return 0;
}运行结果： 
3.指针的关系运算
指针之间也是可以比较大小的
来看代码：
cpp
#include <stdio.h>
int main()
{
int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };
int* p = &arr[0];
int sz = sizeof(arr) / sizeof(arr[0]);
while (p < arr + sz) //指针的⼤⼩⽐较
{
printf("%d ", *p);
p++;
}
return 0;
}运行结果： 
是不是又被震惊到了，哇呜，竟然还可以这么写。