目录

初阶指针一、指针的概念二、指针和指针类型1. 为什么指针有多种类型？？2. 指针+-整数的意义是什么？？3. 指针+-指针有什么意义？？4. 得到了变量的地址有什么用呢？？（指针解引用）

三、野指针1. 野指针是什么？？2. 什么情况会造成野指针？？3. 如何能够防止野指针的出现？？

四、指针和数组五、二级指针

进阶指针一、字符指针二、指针数组1. 指针数组的定义2. 指针数组的使用

三、数组指针1. 如何定义数组指针？？2. 数组的地址和数组首元素的地址的区别

四、函数指针1. 函数指针的定义2. &(函数名) vs（函数名）

五、函数指针数组1. 函数指针数组的定义2. 函数指针数组的使用

六、指向函数指针数组的指针函数指针数组的指针的定义

七、回调函数1. 回调函数的定义2. 回调函数的使用

结尾

初阶指针

一、指针的概念

指针？？是？？

指针是内存中一个最小单元的编号，也就是地址平时口语中说的指针，通常指的是指针变量，是用来存放内存地址的变量

所以说:指针就是地址，人们口中的指针变量也是指针。

指针变量？？是？？

我们可以通过<code>&(取地址操作符）取出变量的内存与实地址，把地址可以存放到一个变量中，这个变量就是指针变量。

int main()

{

int c = 520; //将520赋给c

int* ch = &c;//将整形c的地址取出来放在ch中

printf("%p", ch);

return 0;

}

指针变量的大小？？是？？

指针的大小在32位平台是4个字节，在64位平台是8个字节。

二、指针和指针类型

1. 为什么指针有多种类型？？

变量有多种类型，那么指针也会也有多种类型吧？？

是的，不同类型的变量的地址就应该放在对应的指针变量中。

int main()

{

int a = 0;

int* pa = &a;

double b = 0;

double* pb = &pb;

char c = 'w';

char* pc = &c;

return 0;

}

---

2. 指针±整数的意义是什么？？

明明都是地址，为什么要区分是什么类型的呢？？

那是因为不同类型的指针±整数所跳过的字节数不同。

int main()

{

int a = 0;

int* pa = &a;

printf("%p %p\n", pa, pa + 1);

double b = 0;

double* pb = &pb;

printf("%p %p\n", pb, pb + 1);

char c = 'w';

char* pc = &c;

printf("%p %p\n", pc, pc + 1);

return 0;

}

从上图中我们可以看出：

<code>int*类型的指针 + 1 是跳过四个字节

double*类型的指针 + 1 是跳过八个字节

char*类型的指针 + 1 是跳过一个字节

诶，看着很眼熟？？

int 类型变量的大小是 四个字节？

double类型变量的大小是八个字节？

char类型变量的大小是一个字节？

难道？难道？没错！！！就是你猜想的那样…

指针±整数对应的是指针向前/向后移动的大小（指针指向变量类型大小 * 整数）

---

3. 指针±指针有什么意义？？

指针加整数有意义，那么指针 + - 指针呢？？也有意义吗？？

你猜对了！！一半 ！！

指针 + 指针是没有意义的，但是指针 - 指针是有意义的哟！！

指针 - 指针的结果是两个指针之间所隔的元素个数，这种操作通常用于计算数组中两个元素之间的距离。

---

4. 得到了变量的地址有什么用呢？？（指针解引用）

指针的作用就是通过地址取访问指针指向的变量。

指针的类型决定了指针解引用能够访问的字节数。

例如上面的int*类型的指针，解引用能访问四个字节，double*类型的指针可以访问八个字节，char*类型的指针能够访问一个字节

---

三、野指针

1. 野指针是什么？？

野指针是指指向未知内存位置或者已经释放内存的指针。

2. 什么情况会造成野指针？？

引用未初始化的指针、访问已释放内存、数组边界越界等行为都可能导致野指针。

解引用未初始化的指针

int main()

{

int* pa = NULL;

printf("%d", *pa);

return 0;

}

数组的越界访问

int main()

{

char ch[4] = "Love";

for (int i = 0; i <= 4; i++)

{

printf("%c ", ch[i]);

}

return 0;

}

使用已经释放的指针

<code>#include <stdio.h>

#include <stdlib.h>

#include <string.h>

int main()

{

//动态申请4个char类型大小的空间

char* ch = (char*)malloc(sizeof(char) * 4);

if (ch == NULL)

{

return 0;

}

for (int i = 0; i < 4; i++)

{

ch[i] = 'a' + i;

}

//申请来的ch释放，内存还给操作系统

//这时候访问ch中的元素就会造成野指针，打印出随机值

free(ch);

printf("%c", ch[0]);

return 0;

}

---

3. 如何能够防止野指针的出现？？

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

---

四、指针和数组

首先先展示一下指针和数组的例子

<code>int main()

{

int arr[] = { 5 , 2 , 0 };

int* pa = &arr[0];

printf("%p\n", arr);

printf("%p\n", pa);

return 0;

}

从上面的结果中我们可以发现：

<code>arr是数组名，pa是首元素的地址，而两者却相等。

结论：数组名大多数情况都是首元素地址。

例外：（数组的地址和数组首元素的地址的区别后面会讲）

sizeof(数组名),这里的数组名是数组的地址&(数组名)，这里的数组名也是数组的地址

---

那么指针(首元素地址)±整数与&数组名[下标]有什么关系呢？？

int main()

{

int arr[] = { 1 , 3 , 1 , 4 , 5 , 2 , 0 };

int* pa = &arr[0];

for (int i = 0; i < 7; i++)

{

printf("&arr[%d]: %p <---> pa + %d: %p\n", i, &arr[i], i, pa + i);

}

return 0;

}

从上面的图中我们可以得出：指针(首元素地址)±整数与&数组名[下标]是相同的。

---

那么能用下标遍历数组，能用指针(地址)±整数遍历吗？？

<code>int main()

{

int arr[] = { 1 , 3 , 1 , 4 , 5 , 2 , 0 };

int* pa = &arr[0];

for (int i = 0; i < 7; i++)

{

printf("arr[%d]: %d <---> *(pa + %d): %d\n", i, arr[i], i, *(pa + i));

}

return 0;

}

从上图中可以得知：下标和指针(地址)±整数都能够遍历数组。

我们又知道pa是首元素地址，数组名也是首元素地址，那么数组名±整数能遍历数组吗？？

<code>int main()

{

int arr[] = { 1 , 3 , 1 , 4 , 5 , 2 , 0 };

int* pa = &arr[0];

for (int i = 0; i < 7; i++)

{

printf("arr[%d]: %d <---> *(arr + %d): %d\n", i, arr[i], i, *(arr + i));

}

return 0;

}

从上图中可以得出：下标和数组名±整数都可以遍历数组。

---

数组名可以代替首元素地址，那么首元素地址能够代替数组名吗？？

<code>int main()

{

int arr[] = { 1 , 3 , 1 , 4 , 5 , 2 , 0 };

int* pa = &arr[0];

for (int i = 0; i < 7; i++)

{

printf("pa[%d]: %d <---> *(pa + %d): %d\n", i, pa[i], i, *(pa + i));

}

return 0;

}

从上图中我们可以得出：数组首元素地址可以代替数组名。

结论：（我们可以通过指针直接访问数组）

<code>指针(首元素地址)+-整数与&数组名[下标]是相同的。下标和指针(首元素地址)+-整数都能够遍历数组。下标和数组名+-整数都可以遍历数组。数组首元素地址可以代替数组名。arr[i] = *(arr + i) = *(pa + i) = pa[i]

---

五、二级指针

变量有地址，指针变量也是变量，那么指针变量也有地址吗？？

当然，指针变量也有地址，而存储指针的变量叫做二级指针。

int main()

{

int arr[] = { 1 , 3 , 1 , 4 , 5 , 2 , 0 };

int* pa = &arr[0];

int** ppa = &pa;

printf("ppa : %p\n", ppa);

printf(" pa : %p\n", pa);

printf("*ppa: %p\n", *ppa);

return 0;

}

二级指针存储的是一级指针的地址，而指针解引用可以找到被指针指向的变量，那么这里二级指针解引用也可以找到一级指针。

---

进阶指针

一、字符指针

对于字符指针我们常见的使用方法是先创建一个字符变量，再创建一个字符指针变量，将字符变量的的地址赋给字符指针变量。

<code>int main()

{

char c = 'v';

char* ch = &c;

printf("%p", ch);

return 0;

}

另一种使用方法则是创建一个字符指针变量，将字符串的首元素地址赋给他。

注意：这里是将字符串中的首元素地址存在 ch 中，而非字符串的地址。

int main()

{

char* ch = "chineseperson04";

printf("%p", ch);

return 0;

}

二、指针数组

1. 指针数组的定义

指针数组是一种存储指针的数组。

int main()

{

int arr1[] = { 5 , 2 , 1 , 1 , 3 , 1 , 4 };

int arr2[] = { 5 , 2 , 0 , 1 , 3 , 1 , 4 };

int arr3[] = { 9 , 4 , 2 , 0 , 0 , 0 , 0 };

int* arr[] = { arr1 , arr2 , arr3 };

int i = 0;

for (i = 0; i < 3; i++)

{

printf("%p\n", arr[i]);

}

return 0;

}

---

2. 指针数组的使用

指针数组是存储一级指针的数组，而一级指针指向的是数组，有没有发现指针数组的使用与二维数组很想，但两者却不能看成一个东西。

<code>int main()

{

int arr1[] = { 5 , 2 , 1 , 1 , 3 , 1 , 4 };

int arr2[] = { 5 , 2 , 0 , 1 , 3 , 1 , 4 };

int arr3[] = { 9 , 4 , 2 , 0 , 0 , 0 , 0 };

int* arr[] = { arr1 , arr2 , arr3 };

int i = 0;

for (i = 0; i < 3; i++)

{

for (int j = 0; j < 7; j++)

{

printf("%d ", arr[i][j]);

}

printf("\n");

}

return 0;

}

---

三、数组指针

1. 如何定义数组指针？？

数组指针是用来存放数组地址的指针。

数组指针变量如何定义：（假设这里的指针变量是 <code>p ，数组存放的 int 类型的变量）

首先它是指针那么就不能与[ ]先结合----（*p）

其次它指向的内容是数组 ---- (*p)[ ] ----[ ]中为数组的元素个数

最后它指向数组存储变量的类型为什么 ---- int（*p）[]

int main()

{

int arr[10] = { 0 , 1, 2, 3, 4, 5, 6, 7, 8, 9 };

int(*p)[10] = &arr;

printf("%p", p);

return 0;

}

2. 数组的地址和数组首元素的地址的区别

区别：（ &arr 与 arr ）

那么取出数组的地址和数组首元素的地址有什么区别呢？？

这里我们用代码测试一下！！

int main()

{

int arr[10] = { 0 , 1, 2, 3, 4, 5, 6, 7, 8, 9 };

printf("%p\n", &arr); //取出数组的数组

printf("%p\n", arr); //取出数组首元素的地址

printf("%p\n", &arr[0]); //取出数组首元素的地址

return 0;

}

这里取出数组的地址和数组首元素的地址好像没什么区别，那么它们就是一样的吗？？

这里我们进入下一个测试环节，让它们取出来的地址 <code>+1 试试。

int main()

{

int arr[10] = { 0 , 1, 2, 3, 4, 5, 6, 7, 8, 9 };

printf("%p\n", &arr); //取出数组的数组

printf("%p\n", arr); //取出数组首元素的地址

printf("%p\n", &arr[0]); //取出数组首元素的地址

printf("\n");

printf("%p\n", &arr + 1);

printf("%p\n", arr + 1);

printf("%p\n", &arr[0] + 1);

return 0;

}

诶？这里 <code>+1 得到的地址不同，分析一下。

（1）数组首元素地址 +1 ：这里的地址在十六进制的状态下，相比之下地址的大小增加了 4 ，十进制下也是 4 ，数组储存变量是 int 内存大小也是 4 个字节 ，这里我们可以得到数组首元素地址 +1 ，也就是跳过了一个变量大小的字节数。

（2）数组地址 +1 ：这里的地址在十六进制的状态下，相比之下地址的大小增加了 28 ，十进制下就是 40 ，数组储存变量是 int 内存大小也是 4 个字节并且数组元素个数是 10 个元素 ，这里我们可以得到数组首元素地址 +1 ，也就是跳过了一个数组大小的字节数。

结论：

数组首元素地址 +1 ，跳过一个变量的大小。数组地址 +1 ， 跳过一个数组的大小

---

四、函数指针

1. 函数指针的定义

函数指针是一种指向函数的指针变量，它存储着函数的地址。函数指针的类型由函数的返回值类型和参数类型组成，可以用以下语法定义：

返回值类型(*指针变量名)(变量列表)

这里写一个例子：

int Add(int x, int y)

{

return x + y;

}

int main()

{

int (*pf)(int, int) = &Add;

int a = 10, b = 30;

int c = 0;

c = (*pf)(a, b);

printf("%d", c);

return 0;

}

---

2. &(函数名) vs（函数名）

int Add(int x, int y)

{

return x + y;

}

int main()

{

int (*pf)(int, int) = &Add;

printf("%p\n", &Add);

printf("%p\n", Add);

return 0;

}

这里我们得到 <code>&(函数名) vs （函数名） 是一样的。

那么这里就可以进行下面的推理：

int Add(int x, int y)

{

return x + y;

}

int main()

{

int (*pf)(int, int) = &Add;

int a = 10, b = 30;

int add1 = 0 , add2 = 0;

int add3 = 0, add4 = 0;

//add1 通过函数名掉用函数

add1 = Add(a, b);

printf("%d\n", add1);

//add2 通过函数指针存储函数的地址，再解引用找到函数，调用函数

add2 = (*pf)(a, b);

printf("%d\n", add2);

//由于上面得到 (&Add) 与 Add 相同

//那么这里 ( pf 对应 &Add ) 与 ( (*pf) 对应 ADD )

//所以这里可以得到这里的 * 是没有用的，下面的测试也证明了这一点

add3 = pf(a, b);

printf("%d\n", add3);

add4 = (******pf)(a, b);

printf("%d\n", add4);

}

五、函数指针数组

1. 函数指针数组的定义

函数指针数组是一个数组用来存储函数指针的。

如何定义一个函数指针数组：假设数组存储的是 <code>int (*)(int ,int)

首先是一个数组：那么就要先于[]结合 ---- pf[]

然后数组存储的是函数指针：int（*pf[])(int ,int) ----方块中的是元素个数

---

2. 函数指针数组的使用

这里使用函数指针数组完成一个简易版的计算器。

int add(int x, int y)

{

return x + y;

}

int sub(int x, int y)

{

return x - y;

}

int mul(int x, int y)

{

return x * y;

}

int div(int x, int y)

{

return x / y;

}

calculate(int (*pf)(int, int))

{

int x = 0, y = 0;

printf("请输入两个操作数\n");

scanf("%d%d", &x, &y);

printf("%d\n", pf(x, y));

}

int main()

{

int (*pf[4])(int, int) = { add , sub , mul , div };

int option = 0;

while (1)

{

printf("*************************\n");

printf("**** 1:add 2:sub ****\n");

printf("**** 3:mul 4:div ****\n");

printf("*************************\n");

printf("请选择:>");

scanf("%d", &option);

switch (option)

{

case 1:

calculate(add);

case 2:

calculate(sub);

case 3:

calculate(mul);

case 4:

calculate(div);

default :

printf("输入错误，请重新选择\n");

}

}

return 0;

}

六、指向函数指针数组的指针

函数指针数组的指针的定义

如何定义一个函数指针数组的指针：假设数组存储的是 int (*)(int ,int)

首先是一个指针：那么就要先于*结合 ---- (*pf)

然后指针指向的是函数指针数组：(*pf)[]----方块中的是元素个数

最后数组存储的元素类型是：int（*(*pf)[])(int ,int) ----方块中的是元素个数

int add(int x, int y)

{

return x + y;

}

int sub(int x, int y)

{

return x - y;

}

int mul(int x, int y)

{

return x * y;

}

int div(int x, int y)

{

return x / y;

}

int main()

{

int (*pf[4])(int, int) = { add , sub , mul , div };

int(*(*ppf)[4])(int, int) = &pf;

return 0;

}

七、回调函数

1. 回调函数的定义

回调函数是一种函数，它作为参数传递给另一个函数，并且在其它函数执行完特定操作后被调用。

---

2. 回调函数的使用

这里使用回调函数实现 qsort() 函数的模拟(原理不同，这里使用冒泡排序的底层原理)

void Bubble_sort(void* base , size_t num , size_t width,

int (*Cmp)(const void * p1 , const void* p2)) //这里函数返回值类型需要按需求改

{

size_t i = 0;

for (i = 0; i < num - 1; i++)

{

for (size_t j = 0; j < num - i - 1; j++)

{

if (Cmp((char*)base + j * width , (char*)base + (j + 1) * width) > 0 )

{

Swap((char*)base + j * width, (char*)base + (j + 1) * width , width);

}

}

}

}

---

结尾

如果有什么建议和疑问，或是有什么错误，大家可以在评论区中提出。

希望大家以后也能和我一起进步！！🌹🌹

如果这篇文章对你有用的话，希望大家给一个三连支持一下！！🌹🌹