目录
1.指针是什么？
指针理解的2个要点：
1. 指针是内存中一个最小单元的编号，也就是地址
2. 平时口语中说的指针，通常指的是指针变量，是用来存放内存地址的变量
内存会被分为一个一个内存单元，每个内存单元占一个字节
内存单元的编号：
对于32位的电脑，有32根地址线/数据线 - 电线 - 通电后产生正电( 1 )/负电( 0 )
通电后产生的二进制序列(编号)共有2^32种，每一种都对应内存中的一个内存单元，该编号称为内存单元的地址
总结：指针就是地址，口语中说的指针通常指的是指针变量。
指针变量：
我们可以通过&（取地址操作符）取出变量的内存其实地址，把地址可以存放到一个变量中，这个变量就是指针变量
void test1()
{
int a = 10; //向内存申请四个字节的空间,存放10
printf("%p\n", &a); //取地址 00AFFC8C
int* pa = &a; //地址也是一个值，可以存储到pa变量中 - pa就是指针变量
//此时的*是告诉读者pa是一个指针变量
//此时的int表示a的类型是int类型
*pa= 20; //解引用操作符
printf("a = %d\n", a);
char ch = 'w'; //向内存申请一个字节的空间,存放'w'
char* pc = &ch;
*pc = 'a';
printf("ch = %c\n", ch); //ch = a
}总结：
指针是用来存放地址的，地址是唯一标示一块地址空间的。
指针的大小在32位(32bit)平台是4个字节，在64位平台是8个字节。
2.指针和指针类型
既然指针的大小都是4个字节(32位)，为什么定义指针变量时还要分int、char、...呢？
指针类型的意义：
1.指针的类型决定了，对指针解引用的时候有多大的权限（能操作几个字节）
2.指针进行+ -整数的时候，指针的类型决定了指针向前或者向后走一步有多大（距离）
void test2()
{
//指针类型的意义：
//1.指针类型解引用操作时，能一次性访问几个字节
//2.指针进行+ -整数的时候，指针的类型决定了指针向前或者向后走一步有多大（距离）。
int a = 0x11223344;
int* pa = &a;
char* pc = &a;
*pa = 0;//访问4个字节
*pc = 0;//访问1个字节
//当使用int*pa定义时，*pa = 0让a的4个字节全部改成了0
// 而用char*pa定义时，*pa = 0只让a的1个字节变成了0
printf("%p\n", pa); //010FFB60
printf("%p\n", pa + 1);//010FFB64 向后走了4个字节
printf("%p\n", pc); //010FFB60
printf("%p\n", pc + 1);//010FFB61 向后走了1个字节
}void test3()
{
int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };
int* pa = arr;
char* pb = arr;
int i = 0;
for (i = 0; i < 10; i++)
{
printf("%d\n", *(pa + i));//1 2 3 4 5 6 7 8 9 10
}
for (i = 0; i < 10; i++)
{
printf("%d\n", *(pb + i));//1 0 0 0 2 0 0 0 3 0
}
//因为1 2 3在内存中为 01 00 00 00 02 00 00 00 03 00 00 00
//用char定义指针变量，pb每次+1，只向前走了一个字节
char arr1[] = "abcdef";
char* pc = arr1;
int* pd = arr1;
for (i = 0; i < 6; i++)
{
printf("%c\n", *(pc + i));// a b c d e f
}
}3.野指针
概念： 野指针就是指针指向的位置是不可知的（随机的、不正确的、没有明确限制的）
3.1 野指针成因
1. 指针未初始化
void test4()
{
int* p;
//p就是野指针
//p是指针变量，也是局部变量。局部变量不主动初始化，默认是随机值
*p = 20;//内存中随机找了一个位置 放入20
}2. 指针越界访问
当指针指向的范围超出数组的范围时，p就是野指针
void test5()
{
int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };
int* p = arr;
int i = 0;
for (i = 0; i <= 10; i++) //循环11次时，越界访问了
{
*p = 0;
p++;
}
}
3. 指针指向的空间释放
int* test6()
{
int a = 10;
return &a;
}
int main()
{
int *p = test6();//p就是一个野指针
return 0;
}当调用test6()结束时，局部变量a开辟的空间就会被销毁，此时*p记录的地址没有意义
3.2 如何规避野指针
1. 指针初始化
2. 小心指针越界
3. 指针指向空间释放及时置NULL
4. 避免返回局部变量的地址
5. 指针使用之前检查有效性
4.指针运算
4.1 指针+-整数
void test8()
{
char arr[] = { 'a', 'b', 'c', 'd' };
char* p = arr;
int i = 0;
for (i = 0; i < 4; i++)
{
printf("%c\n", *p++);//++优先级高于*
}
/*int i = 0;
for (i = 0; i < 4; i++)
{
printf("%c\n", *(p+i)); // a b c d
}*/
}#define N_VALUES 5
float values[N_VALUES];
float *vp;
//指针+-整数；指针的关系运算
for (vp = &values[0]; vp < &values[N_VALUES];)
{
*vp++ = 0;
}注：指针也可以比大小
4.2 指针-指针
指针 - 指针 得到的是指针和指针之间的元素个数
前提条件：两个指针指同一块空间
void test9()
{
char ch[5] = { 0 };
int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };
printf("%d\n", &arr[9] - &arr[0]); //9
printf("%d\n", &arr[9] - &ch[0] ); //err
//指针 - 指针 得到的是指针和指针之间的元素个数
//前提条件：两个指针指同一块空间
}例如：求字符串长度
int my_strlen(char* str)
{
char* start = str;
while (*str != '\0')
{
str++;
}
return str - start;
/*int count = 0;
while (*str != '\0')
{
count++;
str++;
}
return count;*/
}
void test10()
{
char arr[] = "abcdef";
//int len = strlen(arr);
int len = my_strlen(arr);
printf("%d\n", len);
}
int main()
{
test10();
return 0;
}4.3 指针的关系运算
已知:数组是连续存放的，随着数组下标的增长，地址由低到高变化
void test12()
{
#define N_VALUES 5
float values[N_VALUES];
float* vp;
for (vp = &values[N_VALUES]; vp > &values[0];)
{
*--vp = 0;
}
}可以这样简化：
for(vp = &values[N_VALUES-1]; vp >= &values[0];vp--)
{
*vp = 0;
}
实际在绝大部分的编译器上是可以顺利完成任务的，然而我们还是应该避免这样写，因为标准并不保证它可行。
标准规定：
允许指向数组元素的指针与指向数组最后一个元素后面的那个内存位置的指针比较，但是不允许与指向第一个元素之前的那个内存位置的指针进行比较。
5. 指针和数组
数组名是什么？我们来看一个例子
void test13()
{
int arr[10] = { 1,2,3,4,5,6,7,8,9,0 };
printf("%p\n", arr);
printf("%p\n", &arr[0]);
}运行结果：
可见数组名和数组首元素的地址是一样的。
结论：数组名表示的是数组首元素的地址。(两个例外，1.&数组名，2.sizeof(数组名))
那么这样写代码是可行的：
void test14()
{
int arr[10] = { 1,2,3,4,5,6,7,8,9,0 };
int* p = arr;//p存放的是数组首元素的地址
int i = 0;
for (i = 0; i < 10; i++)
{
printf("%d\n", *(p + i));
}
}数组是指针吗？ NO
指针是数组吗？ NO
但是，数组可以通过指针来访问
6. 二级指针
void test15()
{
int a = 10;
int* pa = &a;
int* * ppa = &pa;//此时的ppa为二级指针
int** * pppa = &ppa;//pppa为三级指针
}对于上述代码：a的地址存放于pa中，pa的地址存放于ppa中。pa为一级指针，ppa为二级指针
对于二级指针的运算有：
*ppa 通过对ppa中的地址进行解引用，这样找到的是 pa ， *ppa 其实访问的就是 pa
int b = 20;
*ppa = &b;//等价于 pa = &b;**ppa 先通过 *ppa 找到 pa ,然后对 pa 进行解引用操作： *pa ，那找到的是 a
**ppa = 30;
//等价于*pa = 30;
//等价于a = 30;7. 指针数组
指针数组是指针还是数组？ 答案：是数组。是存放指针的数组。
数组我们已经知道
整形数组 int arr1[10] 存放10个整型
字符数组 char arr2[6] 存放6个字符
那指针数组是怎样的？ int* arr3[5]是什么？
arr3是一个数组，有五个元素，每个元素是一个整形指针。
void test16()
{
int a = 10;
int b = 20;
int c = 30;
int* arr3[5] = { &a, &b, &c };
int i = 0;
for (i = 0; i < 3; i++)
{
printf("%d\n", *arr3[i]);//arr3存放a，b，c的地址，解引用即可访问
}
}