目录
指针是什么？
在计算机科学中，指针（Pointer）是编程语言中的一个对象，利用地址，它的值直接指向
（points to）存在电脑存储器中另一个地方的值。由于通过地址能找到所需的变量单元，可以说，地址指向该变量单元。因此，将地址形象化的称为“指针”。意思是通过它能找到以它为地址的内存单元。
那我们就可以这样理解：
?地址指向了一块确定的内存空间，所以地址被形象的称为指针。
指针
指针是个变量，存放内存单元的地址（编号）。
那对应到代码：
#include <stdio.h>
int main()
{
int a = 10;//在内存中开辟一块空间
int *p = &a;//这里我们对变量a，取出它的地址，可以使用&操作符。
//将a的地址存放在p变量中，p就是一个之指针变量。
return 0;
}总结：指针就是变量，用来存放地址的变量。（存放在指针中的值都被当成地址处理）。
?
那这里的问题是：
- 一个小的单元到底是多大？（1个字节）
- 如何编址？
经过仔细的计算和权衡我们发现一个字节给一个对应的地址是比较合适的。(这里在前面初识C语言章节介绍过)
对于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位机器，如果给64根地址线，那能编址多大空间，自己计算。
这里我们就明白：
- 在32位的机器上，地址是32个0或者1组成二进制序列，那地址就得用4个字节的空间来存储，所以一个指针变量的大小就应该是4个字节。
- 那如果在64位机器上，如果有64个地址线，那一个指针变量的大小是8个字节，才能存放一个地址。
总结：
- 指针是用来存放地址的，地址是唯一标示一块地址空间的。
- 指针的大小在32位平台是4个字节，在64位平台是8个字节。
?
指针和指针类型?
这里我们在讨论一下：指针的类型 我们都知道，变量有不同的类型，整形，浮点型等。那指针有没有类型呢？ 准确的说：有的。
当有这样的代码：
int num = 10;
p = #要将&num（num的地址）保存到p中，我们知道p就是一个指针变量，那它的类型是怎样的呢？ 我们给指针变量相应的类型。
char *pc = NULL;
int *pi = NULL;
short *ps = NULL;
long *pl = NULL;
float *pf = NULL;
double *pd = NULL;这里可以看到，指针的定义方式是： type + * 。 其实： char* 类型的指针是为了存放 char 类型变
量的地址。 short* 类型的指针是为了存放 short 类型变量的地址。 int* 类型的指针是为了存放int 类型变量的地址。
那这里就有疑问了，既然指针的大小在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;
}
在执行结果中我们可以看到，字符指针pc加1，跳过了1个字节；而强制类型转换为整形指针的pi加1后，跳过了4个字节。
指针算法并不依赖于指针的类型。换句话说，如果p是一个指向char的指针，那么表达式p+1就指向下一个char。如果p是个指向float的指针，那么p+1就指向下一个float，其他类型也是如此。
总结：指针的类型决定了指针向前或者向后走一步有多大（距离）。
?
指针的解引用
?
//演示实例
#include <stdio.h>
int main()
{
int n = 0x11223344;
char *pc = (char *)&n;
int *pi = &n;
*pc = 0; //重点在调试的过程中观察内存的变化。
*pi = 0; //重点在调试的过程中观察内存的变化。
return 0;
}
?我们看到字符类型的指针解引用时只能访问一个字节。
?而整型类型的指针解引用能访问4个字节。
总结： 指针的类型决定了，对指针解引用的时候有多大的权限（能操作几个字节）。 比如： char* 的指针解引用就只能访问一个字节，而 int* 的指针的解引用就能访问四个字节
?
野指针
概念： 野指针就是指针指向的位置是不可知的（随机的、不正确的、没有明确限制的）。
野指针成因
? ? ?1. 指针未初始化
#include <stdio.h>
int main()
{
int *p;//局部变量指针未初始化，默认为随机值
*p = 20;
return 0;
}? ?2. 指针越界访问
#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;
}? ?3. 指针指向的空间释放
int* test()
{
int a = 10;
return &a;
}
int main()
{
int* p = test();//a的空间已经被释放
printf("%p\n", p);
return 0;
}这里还有一些我们到动态内开辟的时候再讲。
?
如何规避野指针
1. 指针初始化
2. 小心指针越界
3. 指针指向空间释放即使置NULL
4. 指针使用之前检查有效性
ps：标准定义了NULL 指针，它作为一个特殊的指针变量，表示不指向任何东西。要使一个指针变量为 NULL，你可以给它赋一个零值。
#include <stdio.h>
int main()
{
int *p = NULL;//如果指针没有指向的空间，则将它初始化为空
//....
int a = 10;
p = &a;
if(p != NULL)//判断指针是否为空，对空指针解引用是非法的！
{
*p = 20;
}
return 0;
}指针运算
- 指针+- 整数
- 指针-指针
- 指针的关系运算
指针+-整数
?
#define N_VALUES 5
float values[N_VALUES];
float *vp;
//指针+-整数；指针的关系运算
for (vp = &values[0]; vp < &values[N_VALUES];)
{
*vp++ = 0;
}for语句的初始部分把vp指向数组的第1个元素。
这个例子中的指针运算是用++操作符完成的。增加值1与float 的长度相乘，其结果加到指针vp 上。经过第1次循环之后，指针在内存中的位置如下:?
经过5次循环之后，vp就指向数组最后一个元素后面的那个内存位置。?
? ? ? ?此时循环终止。由于下标值从零开始，所以具有5个元素的数组的最后一个元素的下标值为4。这样，&values[N_VALUES]表示数组最后一个元素后面那个内存位置的地址。当vp到达这个值时，我们就知道到达了数组的末尾，故循环终止。
? ? ? ?这个例子中的指针最后所指向的是数组最后一个元素后面的那个内存位置。指针可能可以合法地获得这个值，但对它执行间接访问时将可能意外地访问原先存储于这个位置的变量。程序员一般无法知道那个位置原先存储的是什么变量。因此，在这种情况下，一般不允许对指向这个位置的指针执行间接访问操作。
?
指针-指针
只有当两个指针都指向同一个数组中的元素时，才允许从一个指针减去另一个指针，如下所示:
?例如：大家还记的字符串函数strlen的实现吗？
int my_strlen(char* s)
{
int count = 0;
while (*s++)
{
count++;
}
return count;
}
int main()
{
char str[] = "abcdefg";
printf("%d\n", my_strlen(str));
return 0;
}今天我们运用指针-指针的方法来实现
int my_strlen(char* s)
{
char* p = s;
while (*p != '\0')//将p指针移动到s字符串的最后一个字符的位置
p++;
return p - s;
}
int main()
{
char str[] = "abcdefg";
printf("%d\n", my_strlen(str));
return 0;
}
?运用这种方法也能实现strlen函数。
总结:指针-指针的结果为两指针之间的元素个数。
ps:如果两个指针所指向的不是同一个数组中的元素，那么它们之间相减的结果是未定义的。就家如果你把两个位于不同街道的房子的门牌号码相减不可能获得这两所房子间的房于数一样。程序予贝无从知道两个数组在内存中的相对位置，如果不知道这一点，两个指针之间的距离就毫无意义。
? ? ? ?越界指针和指向未知值的指针是两个常见的错误根源。当你使用指针运算时，必须非常小心，确信运算的结果将指向有意义的东西。
指针的关系运算
? ? ? ? 对指针执行关系运算也是有限制的。用下列关系操作符对两个指针值进行比较是可能的:
? ? ? ? <? ? ? ? ? ? <=? ? ? ? ? ? ? ? >? ? ? ? ? ? ? ? ? ?>=
? ? ? ? 不过前提是它们都指向同一个数组中的元素。根据你所使用的操作符，比较表达式将告诉你哪个指针指向数组中更前或更后 的元素。标准并未定义如果两个任意的指针进行比较会产生什么结果。
? ? ? ? 然而，你可以在两个任意的指针间执行相等或不相等测试，因为这类比较的结果和编译器选择在何处存储数据并无关系—指针要么指向同一个地址，要么指向不同的地址。
让我们再观察一个循环，它用于清除一个数组中所有的元素。
for(vp = &values[N_VALUES]; vp > &values[0];)
{
*--vp = 0;
}
代码简化, 这将代码修改如下：
?
for(vp = &values[N_VALUES-1]; vp >= &values[0];vp--)
{
*vp = 0;
}实际在绝大部分的编译器上是可以顺利完成任务的，然而我们还是应该避免这样写，因为标准并不保证它可行。
标准规定：
允许指向数组元素的指针与指向数组最后一个元素后面的那个内存位置的指针比较，但是不允许
与指向第一个元素之前的那个内存位置的指针进行比较
指针和数组
?
数组名是什么？我们看一个例子：
?
#include <stdio.h>
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存放的是数组首元素的地址既然可以把数组名当成地址存放到一个指针中，我们使用指针来访问一个就成为可能。
例如：
?
#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("&arr[%d] = %p <====> p+%d = %p\n", i, &arr[i], i, p+i);
}
return 0;
}
?所以 p+i 其实计算的是数组 arr 下标为i的地址。
那我们就可以直接通过指针来访问数组。
如下：
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;
}二级指针
指针变量也是变量，是变量就有地址，那指针变量的地址存放在哪里？ 这就是 二级指针.
对于二级指针的运算有：
- *ppa 通过对ppa中的地址进行解引用，这样找到的是 pa ， *ppa 其实访问的就是 pa.
int b = 20;
*ppa = &b;//等价于 pa = &b;- **ppa 先通过 *ppa 找到 pa ,然后对 pa 进行解引用操作： *pa ，那找到的是 a.
?
**ppa = 30;
//等价于*pa = 30;
//等价于a = 30;本章内容只是对指针的初步学习，后面进阶部分会更加详细讲解。
ps：部分内容摘自《C和指针》。
来都来了点个赞吧~~~