指针初阶
1.指针是什么
指针是什么？
指针理解的2个要点：
- 指针是内存中一个最小单元的编号，也就是地址
- 平时口语中说的指针，通常指的是指针变量，是用来存放内存地址的变量
(单元编号 == 地址 == C语言中：指针)
那我们可以这样理解：
内存:
指针变量
我们可以通过&（取地址操作符）取出变量的内存其实地址，把地址可以存放到一个变量中，这个
变量就是指针变量
int main()
{
int a = 10;//是向内存中的栈区空间申请4个字节的空间，这4个字节用来存放10这个数值
int* pa = &a;//这里我们对变量a，取出它的地址，可以使用&操作符。
//a变量占用4个字节的空间，这里是将a的4个字节的第一个字节的地址存放在p变量中，p就是一个之指针变量。
//pa 0x000112233
return 0;
}
总结：
指针变量，用来存放地址的变量。（存放在指针中的值都被当成地址处理）。
那这里的问题是：
1.一个小的单元到底是多大？（1个字节）
2.如何编址？
经过仔细的计算和权衡我们发现一个字节给一个对应的地址是比较合适的。
对于32位的机器，假设有32根地址线，那么假设每根地址线在寻址的时候产生高电平（高电压）和低电平（低电压）就是（1或者0）；
那么32根地址线产生的地址就会是：
- 内存被划分为一个个内存单元，每个内存单元的大小是1个字节
- 每个字节的内存单元都有一个编号，这个编号就是地址，地址就是C语言中的指针
- 地址要储存的话放在指针变量中
- 每个内存单元都有唯一的地址来标识
- 在32位机器上地址的大小是4个字节，所以指针变量的大小也是4个字节
同理：在64位机器上地址的大小是8个字节，所以指针变量的大小也是8个字节
2.指针和指针类型
我们看以下代码：
int main()
{
printf("%d\n", sizeof(char*));
printf("%d\n", sizeof(short*));
printf("%d\n", sizeof(int*));
printf("%d\n", sizeof(double*));
}
2.1 指针±整数
代码演示：
int main()
{
int a = 0;
int* pa = &a;
char* pc = &a;
printf("%d\n", pa);
printf("%d\n", pa+1);
printf("%d\n", pc);
printf("%d\n", pc+1);
}
运行结果：
指针类型是有意义的
指针类型决定了指针+1/-1跳过几个字节
char的指针+1跳过1个字节
short的指针+1跳过2个字节
int的指针+1跳过4个字节
double的指针+1跳过8个字节
2.2 指针的解引用
指针类型是有意义的
指针类型决定指针解引用时访问几个字节
比如：char* 的指针解引用就只能访问一个字节，而 int* 的指针的解引用就能访问四个字节。
3.野指针
概念： 野指针就是指针指向的位置是不可知的（随机的、不正确的、没有明确限制的）
3.1 野指针成因
- 指针未初始化
代码演示：
int main()
{
int* p;//未初始化
*p = 20;
return 0;
}
- 指针访问越界
代码演示：
int main()
{
int arr[10] = {
0 };
int* p = arr;
int i = 0;
for (i = 0; i <= 10; i++)//指针访问越界
{
//当指针指向的范围超出数组arr的范围时，p就是野指针
*p = -1;
p++;
}
return 0;
}
- 指针指向的空间释放
代码演示：
int* test()
{
int a = 10;//0x0040fe44
return &a;//地址已返回出函数销毁
}
int main()
{
//0x0040fe44
int* p = test();
//p就是野指针
printf("%d", p);
return 0;
}
3.2如何避免野指针
-
指针初始化
-
小心指针越界
-
指针指向空间释放即使置NULL
-
避免返回局部变量的地址
-
指针使用之前检查有效性
int main()
{
int* p = NULL;
*p = 20;//空指针不允许访问
//....
if (p != NULL)
{
//...确保非控指针在使用
}
return 0;
}
4.指针运算
4.1 指针±整数
代码演示1：
int main()
{
int arr[10] = {
1,2,3,4,5,6,7,8,9,10 };
// 0 1 2 3 4 5 6 7 8 9
//是指针打印数组内容
int* p = arr;
int i = 0;
//p --> arr
//p == arr
//p+i == arr+i
//*(p+i) == *(arr+i) == arr[i]
//*(arr+i) == arr[i]
//*(i+arr) ==i[arr]//[]仅为操作符
for (i = 0; i < 10; i++)
{
printf("%d ", *(p + i));
//printf("%d ", *(arr + i));
//printf("%d ", arr[i]);
//printf("%d ", i[arr]);
//p指向的是数组首元素
//p+i是数组下标为i的元素地址
//p+i起始时跳过i*sizeof(int)个字节
}
return 0;
}
运行结果：
代码演示2：
#define N_VALUES 5
int main()
{
float values[N_VALUES];
float* vp;
for (vp = &values[0]; vp < &values[N_VALUES];)
{
*vp++ = 0;
}
return 0;
}
分析：
4.2 指针-指针
案例1：
int main()
{
int arr[10] = {
0 };
//
//指针-指针的前提：两个指针指向同一块区域，指针类型时相同的
//指针-指针差值的绝对值，指针和指针之间的元素个数
//
printf("%d\n", &arr[9] - &arr[0]);
printf("%d\n", &arr[0] - &arr[9]);
return 0;
}
运输结果：
案例2：
//模拟实现strlen
//1.计算器
//2.递归
size_t my_strlen(char* str)
{
char* start = str;
while (*str)
{
str++;
}
return str - start;
}
int main()
{
char arr[] = "abcdef";
size_t len = my_strlen(arr);
printf("%zd\n", len);
return 0;
}
运输结果：
4.3 指针的关系运算
代码演示1：
int main()
{
float values[N_VALUES];
float* vp;
for (vp = &values[N_VALUES]; vp > &values[0];)
{
*--vp = 0;
}
return 0;
}
分析：
代码2（代码1修改如下）：
#define N_VALUES 5
int main()
{
float values[N_VALUES];
float* vp;
for (vp = &values[N_VALUES - 1]; vp >= &values[0]; vp--)
{
*vp = 0;
}
return 0;
}
分析：
实际在绝大部分的编译器上是可以顺利完成任务的，然而我们还是应该避免这样写，因为标准并不保证它可行。
标准规定：
允许指向数组元素的指针与指向数组最后一个元素后面的那个内存位置的指针比较，但是不允许与
指向第一个元素之前的那个内存位置的指针进行比较。
5.指针和数组
- 指针就是指针，指针变量就是一个变量，存放的地址，指针变量的大小是4/8
- 数组就是数组，可以存放一组数，数组的大小取决于元素类型和个数
- 数组的数组名是首元素地址
- 通过一个指针可以访问数组元素
数组名表示数组首元素地址，但有两个例外
- sizeof（数组名），数组名单独放在sizeof内部，数组名表示整个数组，计算的是数组的大小，单位是字节
- &数组名，数组名表示整个数组，取出的事数组的地址，数组的地址和数组首元素地址的值是一样的，但是类型和意义不同
代码案例1：
int main()
{
int arr[10] = {
0 };
printf("%d\n", arr);
printf("%d\n", arr+1);
//
printf("%d\n", &arr[0]);
printf("%d\n", &arr[0]+1);
//
printf("%d\n", &arr);
printf("%d\n", &arr+1);
//
printf("%d\n", sizeof(arr));
}
代码案例二：
#define _CRT_SECURE_NO_WARNINGS 1
#include<stdio.h>
int main()
{
int arr[10] = {
0 };
int* p = arr;
int i = 0;
for (i = 0; i < 10; i++)
{
printf("%p===%p\n", p+i, arr+i);
}
return 0;
}
运行结果：
6.二级指针
指针变量也是变量，是变量就有地址，那指针变量的地址存放在哪里？
这就是 二级指针 。
二级指针变量是存放一级指针变量地址的
代码案例1：
int main()
{
int a = 10;
int* pa = &a;//pa是指针变量，一级指针变量
int* * ppa = &pa;//ppa指针变量，二级指针变量
**ppa = 20;//*ppa得出pa-->**ppa==*pa==a
printf("%d", a);
return 0;
}
运行结果：
- *ppa 通过对ppa中的地址进行解引用，这样找到的是 pa ， *ppa 其实访问的就是 pa
- **ppa 先通过 *ppa 找到 pa ,然后对 pa 进行解引用操作： *pa ，那找到的是 a .
代码案例2：
7.指针数组
指针数组是指针还是数组？
是数组。是存放指针的数组。
数组我们已经知道整形数组，字符数组。
int arr1[5];
char arr2[5]
指针数组：
int* arr3[5];
代码案例：
int main()
{
int arr1[] = {
1,2,3,4,5 };
int arr2[] = {
1,2,3,4,5 };
int arr3[] = {
1,2,3,4,5 };
int* arr[] = {
arr1,arr2,arr3 };
int i = 0;
for (i = 0; i < 3; i++)
{
int j = 0;
for (j = 0; j < 5; j++)
{
printf("%d", arr[i][j]);
}
printf("\n");
}
return 0;
}
运行结果：
不知不觉，指针初阶以告一段落。通读全文的你肯定收获满满，让我们继续为C语言学习共同奋进。