[C语言] 指针初阶

一. 指针是什么

指针: 就是地址, 是内存中一个最小单元的编号， 唯一标识一块地址空间
指针变量: 就是用来存储地址的变量, 平常说的指针就是指针变量。
我们可以通过&（取地址操作符）取出变量的内存地址，把地址存放到一个变量中，这个变量就是指针变量

#include <stdio.h>
int main()
{
    //在内存中开辟一块空间
    int a = 10;
    //这里我们对变量a，取出它的地址，可以使用&操作符。
    int *pa = &a; // pa 里面存放的就是 a 的地址
    //a变量占用4个字节空间, 这里是将a的4个字节的第一个字节的地址存放在pa变量中，pa就是一个指针变量。
    return 0;
}

一个小的单元到底是多大? 一个字节。
如何编址? 一个字节对应一个地址。
32位机器: 32 根地址线, 地址由 32 位 0 1 序列组成, 所以要用 4B 来存储。
64位机器: 64 根地址线, 要用 8B 来存储。
所以, 32位机器, 指针类型占 4B, 64 位机器占 8B。

二. 指针和指针类型

1. 指针的类型

变量有不同的类型，整形，浮点型等。那指针有没有类型呢？答案是有的。
指针的定义方式是： type + *
比如：

char  *pc = NULL;
int   *pi = NULL;
short *ps = NULL;
long  *pl = NULL;
float *pf = NULL;
double *pd = NULL;

char* 类型的指针是为了存放 char 类型变量的地址。
short* 类型的指针是为了存放 short 类型变量的地址。
int* 类型的指针是为了存放 int 类型变量的地址。

注意： 指针所占空间的大小只与平台有关系， 与指针类型无关

2. 指针的类型的意义

既然所有指针类型的大小只与平台有关， 那么指针类型的意义在哪？

• 指针±整数

#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;
}

总结： 指针的类型决定了指针向前或者向后走一步有多大（距离), 字符指针 +1, 地址大小就+1， 整型指针 +1, 地址大小就 + 4 …

char* + n ->  n * sizeof(char)
int* + n ->  n * sizeof(int)
...

• 指针解引用

指针解引用： 就是根据存放的地址找到对应的值的过程

#include <stdio.h>
int main()
{
 	int n = 0x11223344;
 	char *pc = (char *)&n;
 	int *pi = &n;
    *pc = 0;   
 	*pi = 0;   
 	return 0;
}

总结： 指针的类型决定了解引用时指针的访问权限
字符指针访问 1 个字节
整型指针访问 4 个字节
…

三. 野指针

野指针: 指针指向的位置是不可知的（随机的、不正确的、没有明确限制的）的指针

1. 野指针成因：

• 指针未初始化

   int *p;//局部变量指针未初始化，默认为随机值
   *p = 20;

• 指针越界访问

    int arr[10] = {0};
    int *p = arr;
    int i = 0;
    for(i=0; i<=11; i++)
    {
        //当指针指向的范围超出数组arr的范围时，p就是野指针
        *(p++) = i;
    }

• 指针指向的空间已经释放

   int* ptr = (int*)malloc(sizeof(int)); // 分配动态内存
   *ptr = 42;
   printf("Value: %d\n", *ptr); // 输出值
   free(ptr); // 释放内存
   // 由于内存已经被释放，ptr 成为野指针
   printf("Value: %d\n", *ptr); // 这里可能会导致不可预测的行为

2. 如何避免野指针

• 指针初始化
• 小心指针越界
• 指针指向空间释放，及时置NULL
• 避免返回局部变量的地址
• 指针使用之前检查有效性

四. 指针运算

1. 指针±整数

#define N_VALUES 5
float values[N_VALUES];
float *vp;
//指针+-整数；指针的关系运算
for (vp = &values[0]; vp < &values[N_VALUES];)
{
     *vp++ = 0; // 等价于 *(vp++) = 0
}

指针++, 就指向下一个元素
这段代码就是将这个 float 数组里面的元素全部赋值为 0

2. 指针-指针

前提: 两个指针指向同一块空间才能相减

char c[10];
int arr[5];
&c[1] - &arr[3]; // 两个指针不指向同一块空间且指针类型不一样, 直接报错

结果: 指针-指针的结果的绝对值是两个指针之间的元素个数

这里面如果颠倒过来的话就是负值

3. 指针的关系运算

标准规定：
允许指向数组元素的指针与指向数组最后一个元素后面的那个内存位置的指针比较，但是不允许与指向第一个元素之前的那个内存位置的指针进行比较。

for(vp = &values[N_VALUES-1]; vp >= &values[0];vp--)
{
    *vp = 0;
}

这里面最后一次进行比较时, 与数组起始位置的前一个位置进行比较, 而这种行为是不允许的, 但是与数组最后一个元素后面的一个位置进行比较是允许的

for(vp = &values[N_VALUES]; vp > &values[0];)
{
    *(--vp) = 0;
}

这种就是允许的

五. 指针和数组

1. 数组

1. 数组名就是数组首元素地址
2. 有两个例外:
   ① sizeof(数组名) ② &arr 这两种情况表示整个数组

既然数组名就是数组首元素地址, 那么数组名其实就是一个指针
所以下面代码就是合理的

int arr[10] = {1,2,3,4,5,6,7,8,9,0};
int *p = arr;//p存放的是数组首元素的地址

所以, 就可以使用指针来访问数组元素

&arr[i] 等价于 p+i

2. 二级指针

二级指针: 存放的是指针的地址

	int a = 10;
	int * pa = &a;
	int ** ppa = &pa; // ppa 就是一个二级指针, 存放 pa 的地址

3. 指针数组

指针数组: 存放指针的数组

更高级的用法: