C 语言复习总结记录六
C 语言复习总结记录六
一 指针
指针是什么 ？
-
指针是内存中一个最小单元的编号，也就是地址
-
指针通常是指指针变量，用来存放内存地址的变量
指针变量 ：通过 &（取地址操作符）取出变量的内存起始地址，把地址可以存放到一个变量中，这个变量就是指针变量
#include <stdio.h>
int main()
{
int a = 10; //在内存中开辟一块空间
int *p = &a; //这里我们对变量 a，取出它的地址，可以使用 & 操作符。
// a 变量占用 4 个字节的空间，这里是将 a 的 4 个字节的第一个字节的地址存放在 p 变量中，p 就是一个指针变量
return 0;
}
总结：
指针变量，用来存放地址的变量（存放在指针中的值都被当成地址处理）
那这里的问题是：
一个小的单元到底是多大？（1个字节）
如何编址？
一个字节一个对应的地址是比较合适的，对于 32 位的机器，假设有 32 根地址线，那么假设每根地址线在寻址的时候产生高电平（高电压）和低电平（低电压）就是（ 1 或者 0 ）；那么 32 根地址线产生的地址就会是：
00000000 00000000 00000000 00000000
00000000 00000000 00000000 00000001
......
11111111 11111111 11111111 11111111
即 2 的 32次方个地址。每个地址标识一个字节，（2^32Byte == 2^32/1024KB == 232/1024/1024MB==232/1024/1024/1024GB == 4 GB） 那就可以给 4G 的空间进行编址
综上在 32 位的机器上，地址是 32 个 0 或者 1 组成二进制序列，地址就得用 4 个字节的空间来存储，所以一个指针变量的大小就应该是4个字节。
那如果在 64 位机器上，如果有 64 个地址线，那一个指针变量的大小是 8 个字节，才能存放一个地址
总结：指针变量是用来存放地址的，一个地址标示一个唯一的内存单元；指针大小在 32 位平台是 4 字节，在 64 位平台是 8 字节
二 指针类型
变量有不同的类型，整形，浮点型等。那指针有没有类型呢 ？指针的定义方式如下 type + *
char *pc = NULL;
int *pi = NULL;
short *ps = NULL;
long *pl = NULL;
float *pf = NULL;
double *pd = NULL;
不同类型的指针，是为了存放不同类型变量的地址
2.1 指针偏移
指针的类型决定了指针偏移的步长（向前或者向后走一步的长度）
#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;
}
2.2 指针解引用
#include <stdio.h>
int main()
{
int n = 0x11223344;
char *pc = (char *)&n;
int *pi = &n;
*pc = 0; //重点在调试的过程中观察内存的变化。
*pi = 0; //重点在调试的过程中观察内存的变化。
return 0;
}
指针类型决定了，对指针解引用的时操作几个字节
比如： char* 指针解引用只能访问一个字节，而 int* 指针解引用能访问四个字节
三 野指针
野指针就是指针指向的位置是不可知的（随机的、不正确的、没有明确限制的）
3.1 野指针成因
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、指针指向的空间释放
还有动态内存的释放（free）
#include <stdio.h>
int main()
{
int *p = NULL;
{
int x = 1;
p = &x;
}
printf("%p\n", p);
printf("%d\n", *p);
return 0;
}
3.2 规避野指针
- 指针初始化
- 小心指针越界
- 指针指向空间释放，及时置 NULL
- 避免返回局部变量的地址
- 指针使用之前检查有效性
#include <stdio.h>
int main()
{
int *p = NULL; //指针初始化
//....
int a = 10;
p = &a;
if(p != NULL) //指针使用之前检查有效性
{
*p = 20;
}
return 0;
}
四 指针运算
4.1 指针 + - 整数
#define N_VALUES 5
float values[N_VALUES];
float *vp;
//指针 +- 整数；指针的关系运算
for (vp = &values[0]; vp < &values[N_VALUES];)
{
*vp++ = 0; //用指针循环给数组元素赋值
}
4.2 指针 - 指针
int my_strlen(char *s)
{
char *p = s;
while(*p != '\0' )
p++;
return p - s; //指针相减返回两地址间的距离
}
4.3 指针关系运算
for(vp = &values[N_VALUES]; vp > &values[0];)
{
*--vp = 0;
}
//修改如下
//当 vp == &values[0] 时，循环结束时就会触发 vp = &values[-1]
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;
}
运行结果说明，数组名和数组首元素的地址是一样的。
结论：数组名表示的是数组首元素的地址（2 种情况除外，sizeof 数组名或 数组名 + 整型值偏移）
//利用指针+偏移的方式打印地址
#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]);
for(int 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;
}
六 二级指针
二级指针就是指向指针的指针
int a = 10;
int *pa = &a;
int **ppa = &pa; //指针变量也是变量，它也有地址, 这里将 pa 的地址赋值给 ppa, 即相当于 ppa 指向 pa 指针(指向指针的指针)
对于二级指针的运算有：
*ppa 通过对 ppa 中的地址进行解引用，找到的是 pa （*ppa 其实访问的就是 pa）
int b = 20;
*ppa = &b; //等价于 pa = &b; 通过二级指针, 修改 pa 指向的目标
**ppa 先通过 *ppa 找到 pa ,然后对 pa 进行解引用操作： *pa ，找到的是 a
**ppa = 30;
//等价于 *pa = 30;
//等价于 a = 30;
七 指针数组
指针数组还是数组。只不过其元素是指针类型
如下所示，arr3 是一个指针数组，它有五个元素，元素的类型是 int* (整型指针)
int* arr3[5];