C语言初阶指针（对指针的初步了解）
目录
一、指针是什么
二、指针和指针类型
2.1 指针+-整数
2.2 指针的解引用
三、野指针
3.1 野指针成因
3.2 如何规避野指针
四、指针运算
4.1 指针+-整数
4.2 指针-指针
4.3 指针的关系运算
五、指针和数组
六、二级指针
七、指针数组
总结
一、指针是什么
指针是一个变量，其值是另一个变量的内存地址。在计算机编程中，指针常用于直接操作内存中的数据，例如动态内存分配和函数参数传递。通过指针，程序可以直接访问内存中的数据，从而实现高效的数据操作和算法实现。
指针理解的2个要点：1. 指针是内存中一个最小单元的编号，也就是地址2. 平时口语中说的指针，通常指的是指针变量，是用来存放内存地址的变量
总结：指针就是地址，口语中说的指针通常指的是指针变量。
#include
int main()
{
int a = 10;//在内存中开辟一块空间
int* p = &a;//这里我们对变量a，取出它的地址，可以使用&操作符。
//a变量占用4个字节的空间，这里是将a的4个字节的第一个字节的地址存放在p变量中，p就是一个之指针变量。
return 0;
} - 在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 类型变量的地址。
- int* 类型的指针是为了存放 int 类型变量的地址。
- short* 类型的指针是为了存放 short 类型变量的地址。
- long* 类型的指针是为了存放long 类型变量的地址。
- float* 类型的指针是为了存放float 类型变量的地址。
- double* 类型的指针是为了存放double 类型变量的地址。
那指针类型的意义是什么？
2.1 指针+-整数
指针的类型决定了指针向前或者向后走一步有多大（距离）。
#include
int main()
{
int a = 0;
int* pa = &a;
char* pc = (char*)&a;
printf("%p\n", pa);
printf("%p\n", pa + 1);
printf("%p\n", pc);
printf("%p\n", pc + 1);
return 0;
} 2.2 指针的解引用
指针的类型决定了，对指针解引用的时候有多大的权限（能操作几个字节）。
比如： char* 的指针解引用就只能访问一个字节，而 int* 的指针的解引用就能访问四个字节。
例：
//演示实例
#include
int main()
{
int n = 0x11223344;
char* pc = (char*)&n;
int* pi = &n;
*pc = 0; //重点在调试的过程中观察内存的变化。
*pi = 0; //重点在调试的过程中观察内存的变化。
return 0;
} 在这个代码中，当我们查看n在内存中存储的数时，可以发现是44 33 22 11。
代码继续运行，当给*pc为0后，可以看到第一个字节中的44变成了00，而在这里pc为char* 类型的指针。
代码继续运行，当给*pi为0后，可以看到四个字节中的全部变成了00，而在这里pi为int* 类型的指针。
所以验证了char* 的指针解引用就只能访问一个字节，而 int* 的指针的解引用就能访问四个字节。
三、野指针
野指针是指未初始化或已经被释放的指针，即指向不确定的内存地址的指针变量。在使用野指针时，由于指针变量中存储的地址是未知的或无效的，可能会导致程序崩溃、数据丢失等不可预测的行为。
3.1 野指针成因
1. 指针未初始化
#include
int main()
{
int* p;
*p = 10;
return 0;
} 2. 指针越界访问
#include
int main()
{
int arr[10] = { 0 };
int* p = arr;
int i = 0;
for (i = 0; i <= 10; i++) //i=10的时候越界了
{
*p = i;
p++;
}
return 0;
} 3. 指针指向的空间释放
#include
int* test()
{
int a = 10;
return &a;
}
int main()
{
int* p = test();
*p = 1;
printf("%d", *p);
return 0;
} 3.2 如何规避野指针
- 指针初始化
- 小心指针越界
- 指针指向空间释放即使置NULL
- 避免返回局部变量的地址
- 指针使用之前检查有效性
#include
int main()
{
int* p = NULL;
//....
int a = 10;
p = &a;
if (p != NULL)
{
*p = 20;
}
return 0;
} 野指针是编程中常见的错误之一，发现野指针问题需要仔细排查代码，避免影响程序的正常运行。
四、指针运算
4.1 指针+-整数
指针加减整数是指在指针类型变量上进行算术运算，例如将指针加上一个整数或减去一个整数。
在C/C++中，当将一个整数加上一个指针时，编译器会根据指针类型的大小自动计算出地址偏移量，然后将偏移量加到指针的地址上。例如，假设有一个int类型的指针变量p和一个整数n，那么p+n的结果就是p指向地址的偏移n个int类型的长度。同样的，当将一个指针减去一个整数时，结果也是类似地计算。
需要注意的是，将指针加减整数可能会超出指针所指向的内存范围，因此需要谨慎操作，以避免出现指针越界或内存访问异常的问题。
#include
int main()
{
int a = 0;
int* pa = &a;
char* pc = (char*)&a;
printf("%p\n", pa);
printf("%p\n", pa + 1);
printf("%p\n", pc);
printf("%p\n", pc + 1);
return 0;
} 4.2 指针-指针
指针减指针是指在两个指针类型变量之间进行算术运算，得到它们之间相差的元素数量。
在C/C++中，指针减指针的结果是一个整数，表示它们之间相差的元素个数。例如，假设有两个指向int类型的指针变量p和q，那么p-q的结果就是它们之间相差的int类型元素个数。
需要注意的是，两个指针类型变量之间进行减法运算，要求它们指向同一个数组或同一块内存中的不同元素。否则，结果将没有意义。此外，还需要注意指针的类型大小和对齐方式，以确保减法运算的结果正确。
#include
int main()
{
int arr[10] = { 0 };
//指针-指针的前提：两个指针指向同一块区域，指针类型时相同的
//指针-指针差值的绝对值，指针和指针之间的元素个数
printf("%d\n", &arr[9] - &arr[0]);
printf("%d\n", &arr[0] - &arr[9]);
return 0;
} 4.3 指针的关系运算
指针可以进行关系运算，包括大于、小于、等于、大于等于、小于等于、不等于等六种运算。
关系运算符的使用方法和普通变量的使用方法是一样的，如>、<、>=、<=、==、!=。其规则如下：
1. 当两个指针指向的是同一个数组、同一个对象、同一个函数或者同一块内存区域时，可以直接进行关系运算符的运算。比较的是指针所指向元素的地址大小关系。
2. 当两个指针指向的不是同一个数组、同一个对象、同一个函数或者同一块内存区域时，就不能直接进行关系运算符的运算。
需要注意的是，指针的比较结果是一个布尔值，即true和false，分别代表指针之间的大小关系成立和不成立。
#include
int main()
{
int arr[10];
int* p;
for (p = &arr[10]; p > &arr[0];)
{
*--p = 0;
}
return 0;
} 五、指针和数组
指针和数组有密切的关系，可以互相转换。
首先，数组名是一个指向数组第一个元素的指针。例如，对于一个名为arr的数组，arr表示指向arr[0]的指针。因此，可以用指针的方式访问数组元素，例如*(arr+1)表示访问arr[1]这个元素。
其次，指针也可以指向数组。指向数组的指针可以用来访问数组中的元素，例如int *p = arr表示将指针p指向数组arr的第一个元素arr[0]。
需要注意的是，指针和数组的关系需要根据具体的场景进行判断。如果需要对数组进行元素的添加、删除、插入等操作，建议使用数组；如果需要使用动态内存分配或者在函数中对数组进行传参，建议使用指针。
如下代码可验证数组名表示的是数组首元素的地址：
#include
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;
} 如下代码用指针访问数组：
#include
int main()
{
int arr[] = { 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;
//arr-->p
//arr == p
//arr+i == p+i
//*(arr+i) == *(p+i) == arr[i]
//*(arr+i) == arr[i]
//*(i+arr) == i[arr]
//3+5
//5+3
for (i = 0; i < 10; i++)
{
printf("%d ", *(p + i));
printf("%d ", *(arr + i));
printf("%d ", arr[i]);
printf("%d ", i[arr]);
printf("%d ", i[p]);
printf("\n");
//p指向的是数组首元素
//p+i 是数组中下标为i的元素的地址
//p+i 其实是跳过了i*sizeof(int)个字节
}
return 0;
} 六、二级指针
二级指针是指一个指针变量的值是另一个指针变量的地址，也就是说，它指向的是一个指针的指针。一级指针是指一个指针变量保存的是某个对象的地址，而二级指针保存的是一个指向指针变量的指针的地址。
在 C 语言中，二级指针通常用于函数参数和动态内存分配中。例如，在函数中传递一个指针的指针作为参数，可以通过这个指针的指针修改原指针的值。具体来说，可以用一个二级指针将指针变量的地址传递给函数，然后在函数中通过二级指针访问这个指针变量，通过修改这个指针变量的值来实现对原指针的修改。
另外，使用二级指针进行动态内存分配也很常见。例如，在动态分配一个二维数组时，需要使用二级指针来管理内存空间。可以先分配一维的数组指针，再分别为每个指针分配一维的数组空间，最终得到一个二维数组。
#include
int main()
{
int a = 10;
int* p = &a;//p是指针变量，一级指针变量
int** pp = &p;//pp指针变量，二级指针变量
**pp = 20;
printf("%d\n", a);//20
//int** * ppp = &pp;//pp是指针变量，三级指针变量
//...
return 0;
} 七、指针数组
指针数组是由一组指针构成的数组。每个指针都指向内存中的一个对象，这些对象可以是相同的类型，也可以是不同的类型。指针数组可以使用下标访问，每个元素都是一个指针。
指针数组在 C 语言中应用非常广泛，常用于动态内存分配、字符串处理、多维数组等场景。使用指针数组可以避免在循环中频繁地进行指针运算，提高代码的效率。同时，指针数组可以方便地处理不同类型的数据结构。
下面是一个指针数组的示例代码，其中包含三个指针，每个指针分别指向一个 int、char 和 double 类型的变量。
#include
int main()
{
int a = 10;
char b = 'c';
double c = 3.14;
int* ptr1 = &a;
char* ptr2 = &b;
double* ptr3 = &c;
void* ptrArr[] = { ptr1, ptr2, ptr3 };//指针数组
return 0;
} 总结
本文是对指针的初步介绍，主要让我们在写代码的时候能够简单的使用指针