指针基础知识(笔记)

1. 概念理解

① 指针的作用：外部服务的提供者
② 我们总是希望外部提供给我们良好的服务,我们只需要提供给ta地址(或金钱等), ta就可以帮我们解决一切困扰，省去我们亲自动手的麻烦。
③ 问：直接building_floor[2] = 106,不是更快么, 为什么还要引入指针?
    答: 此处将数组与指针联系在一起只是为了方便理解。当我们解决更复杂的生活问题时，指针的妙用就会凸显。例如：我们点外卖或者网购时，我们当然也可以自己到店里或者生产地去取，可是为了方便，我们会选择向骑手或者网店付运费，让人家帮我们送到家门口。这种情况下，骑手和网店也可以理解为指针，我们向ta们付了钱，ta们给我们提供服务，省去我们来回奔波的麻烦。
④ windows的快捷方式是指针的一个最典型、最简单的应用。创建快捷方式相当于把程序的绝对地址赋值给那个指针变量(假如是 char *ptr = …)；双击该快捷方式的图标相当于 *ptr; 程序打开的过程相当于把 *ptr作为一个参数传递给程序启动函数

#include<stdio.h>
int main(){int building_floor[5] = {101, 102, 103, 104, 105};//建群for(int i = 0; i < 5; i++){printf("%d : my house number is %d\n", i, building_floor[i]);}//群里发福利，一人一袋大米，103住户不在，请别人帮忙放门口int target_floor = 103;for(int i = 0; i < 5; i++){if(building_floor[i] == target_floor){printf("Ok!\n");break;}}//都在忙，请了个快递代拿，这个时候需要告诉人家准确地址int *courier = &building_floor[2];printf("%p\n", (void *)courier);printf("%p\n", &building_floor[2]);//推荐快递员for(int i = 0; i < 5; i++){printf("%d 's address is %p\n", building_floor[i], (void *)&building_floor[i]);}//我搬家了,搬到了106int *company = courier;*company = 106;printf("%d\n", building_floor[2]);//搬回来了*courier = 103;printf("%d\n", building_floor[2]);printf("%p\n", (void *)courier);printf("%d\n", *courier);courier += 1;printf("%d\n", *courier);int *courier2 = &building_floor[3];printf("%d\n", *courier2);return 0;
}

2. 空指针和野指针

#include<stdio.h>
int main(){//空指针: 还没有指向一个有效内存地址int *ptr = NULL;printf("%p \n", (void *)ptr);// 指向实际地址int x = 100;ptr = &x;printf("%p %d\n", &x, x);printf("%p %d\n", (void *)ptr, *ptr);// 野指针: 指向一个无效的内存地址或者已经被释放的内存地址// 野指针指向了一个无法描述的内存空间，可能产生无法预测的行为// 野指针非常危险, 程序员必须解决这个问题{int y = 104;ptr = &y;printf("%p %d\n", (void *)ptr, *ptr); // 1}// 脱离了上述作用域之后,y这个变量就不复存在了, t它相应的内存空间也会被释放. 无法确定*ptr所占空间是否有了新的数据, 贸然使用可能会导致程序崩溃// 此时的ptr就是一个野指针//printf("%p %d\n", &y, y);printf("%p %d\n", (void *)ptr, *ptr); // 2. 哪怕1、2输出结果相同也不行return 0;
}

3. 计算

#include<stdio.h>
int main(){int numbers[] = {10, 20, 30, 40, 50, 60, 70, 80, 90, 100};int *ptr = numbers;// ptr存的是数组首地址，因为数组在内存中是back to back 的printf("%p \n", (void *)ptr);printf("%p \n", (void *) &numbers[0]);printf("%d \n", *ptr);// 可以不写数组大小的原因// sizeof(numbers): 统计整个数组所占内存空间大小，单位字节// sizeof(numbers[0]); 统计第一个元素所占内存空间的大小int size = sizeof(numbers) / sizeof(numbers[0]);printf("%d %d\n", sizeof(numbers), sizeof(numbers[0]));printf("%d \n", size);/*地址之间的加减法跳跃元素*/ // 指针加法int *start_ptr = &numbers[0];printf("%d \n", *(start_ptr + 1));int offset = 2;printf("%p \n", start_ptr + offset); // 实际增加的字节数是offset *4printf("%p \n", &numbers[0] + offset);// 如果想要+1代表加一个字节，需要用到强制类型转换,强制转换成(char *)printf("%d \n", *(start_ptr + offset));// 不过转换增加了代码复杂度，可读性也差，因而实际编码过程中不常见for(int i = 0; i < 10; i++){printf("%d: %p\n", i + 1, (void *)&numbers[i]);}// 指针减法.访问第二个元素printf("%d \n", *(start_ptr + offset - 1));// 计算指针首尾地址之间的距离. // 微软专门给了一个数据类型ptrdiff_t(有符号整型)来表示指针之间的距离(在32位系统中它通常是int类型, 64位-long int) ,便于跨平台使用int *end_ptr = &numbers[size - 1];printf("%td \n", end_ptr - start_ptr);// 通过指针比较元素位置前后if(start_ptr < end_ptr){printf("start_ptr is ahead of end_ptr\n");}else{printf("start_ptr is behind end_ptr\n");}int x = 78;int y = 120;int *ptr_x = &x;int *ptr_y = &y;printf("x: %p \n", (void *)ptr_x);printf("y: %p \n", (void *)ptr_y);if(ptr_x < ptr_y){printf("ptr_x is ahead of ptr_y\n");}else{printf("ptr_x is behind ptr_y\n");}// 指针顺序遍历for(int *i = start_ptr; i <= end_ptr; i++){printf("%d ", *i);}printf("\n");// 指针逆序遍历for(int *i = end_ptr; i >= start_ptr; i--){printf("%d ", *i);}printf("\n");
}

4. 小结

上述都是指针与数组的关系(数组名作为指针的使用)

5. size_t

        size_t：一个无符号的整数类型，专门用来表示大小、长度和索引。
        c语言设计它的初衷：提高程序在不同平台(跨平台)的可移植性和安全性。
         i++与++i：相同点：效果相同。差异：对于整型循环器而言，两者在性能上差异不大。但如果使用迭代器的话, ++i 在性能上可能会有一些微小的优势。(从定义上来讲，后缀递增 i++需要先去存储原始的值，然后再去返回它，在理论上可能会多一点开销)

#include<stdio.h>
#include<inttypes.h>
int main(){int numbers[] = {10, 20, 30, 40};size_t numbers_size = sizeof(numbers) / sizeof(numbers[0]);int *ptr = numbers;// 输出数组元素原来的值for(size_t i = 0; i < numbers_size; ++i){printf("%" PRId32 " ", *(ptr + i));}printf("\n");// 将数组里每个元素的值都加5, 输出改变后数组元素的值for(size_t i = 0; i < numbers_size; ++i){*(ptr + i) += 5;printf("%" PRId32 " ", *(ptr + i));}return 0;
}

6. 案例一: 指针查找并返回指定元素索引

#include<stdio.h>
#include<inttypes.h>
#include<stdbool.h>
int main(){int32_t values[] = {10, 20, 30, 40, 50};int32_t *ptr = values;int32_t target_value = 30;int32_t *target_ptr = NULL;size_t values_size = sizeof(values) / sizeof(values[0]);size_t index = 0;bool found = false;// 与<stdbool.h>配套使用for(size_t i = 0; i < values_size; ++i){if(*(ptr + i) == target_value){index = i;target_ptr = ptr + i;found = true;break;}}// 专门输出size_t类型的数据if(found){printf("element %" PRId32 " 's index is: %zu \n ", target_value, index);}else{printf("element %" PRId32 " not found!\n", target_value);}return 0;
}

7. 指针访问多维数组(涉及 int (*ptr)[3]解析)

定义一个指针操作一个多维数组

#include<stdio.h>
#include<inttypes.h>
#include<stdbool.h>
int main(){int building_floor[2][3] = {{1, 2, 3}, {4, 5, 6}};// (*ptr)[3]：ptr是一个指针，它指向一个包含3个int元素(数组长度为3)的一维数组// 一维数组指向数组首地址，二维数组指向第一行(二维数组的首地址就是它的第一行数据)// int *ptr[3]：声明了三个指针(即声明了一个包含三个元素的指针数组)int (*ptr)[3] = building_floor;// printf("%p \n", (void *)ptr);// printf("%p \n", &building_floor[0][0]);// printf("%p \n", &building_floor[0][1]);for(int i = 0; i < 2; ++i){for(int j = 0; j < 3; ++j){//不带*的原因：ptr[i]已经相当于地址了，它代表让指针跳到第i行printf("%d ", ptr[i][j]);}printf("\n");}return 0;
}

8. 指针数组

定义多个指针操作不同的数组

#include<stdio.h>
#include<inttypes.h>
int main(){int32_t department1[] = {1001, 1002, 1003};int32_t department2[] = {2001, 2002, 2003, 2004};int32_t department3[] = {3001, 3002, 3003, 3004, 3005};int32_t* department_ptrs[] = {department1, department2, department3};size_t department_sizes[] = {sizeof(department1) / sizeof(int), sizeof(department2) / sizeof(int), sizeof(department3) / sizeof(department3[0])};for(size_t i = 0; i < 3; ++i){printf("department%zu: ", i + 1);// 此处的变量类型老是搞混for(size_t j = 0; j < department_sizes[i]; ++j){//printf("%" PRId32 " ", *(department_ptrs[i] + j));printf("%" PRId32 " ", department_ptrs[i][j]);}printf("\n");}return 0;
}

9. 函数的值传递与地址引用传递

① 函数的值传递(pass by value)

必须借助返回值才能改变数值

#include<stdio.h>
#include<inttypes.h>
void add_five(int32_t value);
int add_five_2(int32_t value);
int main(){int32_t my_value = 10;printf("original value: %" PRId32 "\n", my_value);add_five(my_value);printf("present value: %" PRId32 "\n", my_value); // 输出结果为10(与函数的作用域有关)int32_t number = add_five_2(my_value);printf("present value: %" PRId32 "\n", number); // 输出结果为15my_value = add_five_2(my_value);printf("present value: %" PRId32 "\n", my_value); // 输出结果为15my_value = add_five_2(my_value);printf("present value: %" PRId32 "\n", my_value); // 输出结果为20return 0;
}
void add_five(int32_t value){value += 5;
}int add_five_2(int32_t value){return value += 5;
}

② 地址传递(pass by reference)

指针作为函数参数使用。函数相当于提供外部服务的东西(真正的外部服务–函数)，所以指针在函数里写的是最多的

#include<stdio.h>
#include<inttypes.h>
void add_five(int32_t* value);
int main(){int32_t my_value = 10;printf("original value: %" PRId32 "\n", my_value);add_five(&my_value);printf("present value: %" PRId32 "\n", my_value); // 输出结果为15return 0;}
void add_five(int32_t* value){*value += 5;
}

10. 案例二：指针作为函数返回值

① 需考虑函数的参数类型以及返回值类型是否需要写成指针形式。这个其实我还是拿捏不准。
② 仿写过程中出现的问题：习惯指针的写法以后，很难返回之前的模式。例如 void print_salary(uint32_t* salary) 这个函数打印数组的数值时，会下意识写成printf(“%” PRIu32 " “, *(salary + i))这种形式，printf(”%" PRIu32 " ", salary[i])原先的这种写法就算后续在脑子里一闪而过，也会因为想到指针而怀疑这种写法的正确性。之前听到指针就头疼，现在反而觉得(就上述例子而言)，指针的写法好像比 salary[i]更容易理解。
③ 学到现在突然有点懵：为什么 salary[i] 和 *(salary + i)是等效的? 上述函数中salary保存的是数组首地址，为什么访问数组元素时 salary[i] 不需要加 * 号？
答(gpt): *(salary + i)：对指针 salary 加上索引 i，然后解引用它，可以得到数组的第 i 个元素； salary[i]：在 salary[i] 中，salary 已经是一个指向 uint32_t 的指针，用于访问数组的第 i 个元素。在这种语法中，编译器会自动进行指针解引用，所以你不需要手动使用 * 运算符来解引用 salary。

#include<stdio.h>
#include<inttypes.h>
#define EMPLOYEE_COUNT 5// 集体涨工资
void increase_salary(uint32_t* salary, uint32_t increment);
// 打印工资
void print_salary(uint32_t* salary);
// 返回工资最高的员工
uint32_t* find_highest_salary(uint32_t* salary);
// 返回年终奖
// 因为这个数据用到的不多，因此函数的参数也可以不用写成指针形式
uint32_t cal_bonus(uint32_t* salary);
int main(){uint32_t salary[EMPLOYEE_COUNT] = {3000, 3100, 3200, 3300, 3400};printf("original salary: ");print_salary(salary);uint32_t increment = 10000;increase_salary(salary, increment);printf("present salary: ");print_salary(salary);printf("highest salary: %" PRIu32 "\n", *find_highest_salary(salary));printf("highest bonus: %" PRIu32, cal_bonus(find_highest_salary(salary)));
}
void increase_salary(uint32_t* salary, uint32_t increment){for(size_t i = 0; i < EMPLOYEE_COUNT; ++i){//*(salary + i) += increment;salary[i] += increment;}
}void print_salary(uint32_t* salary){for(size_t i = 0; i < EMPLOYEE_COUNT; ++i){//printf("%" PRIu32 " ", *(salary + i));printf("%" PRIu32 " ", salary[i]);}printf("\n");
}uint32_t* find_highest_salary(uint32_t* salary){uint32_t* highest = salary;for(size_t i = 0; i < EMPLOYEE_COUNT; ++i){// if(*(salary + i) > *highest){//     highest = salary + i;// }if(salary[i] > *highest){*highest = salary[i];}}return (uint32_t*) highest;
}uint32_t cal_bonus(uint32_t* salary){return (*salary) / 10;
}

11. 案例三：游戏案例

// 玩家通过解决谜题来提升等级, 指针和函数搭配使用去更新玩家的经验值和等级
/* 游戏开发的基本概念：玩家属性：exp(经验值)、level(等级)解谜：每当玩家解开一个谜题，ta就可以获得一定数量的经验值等级提升：当玩家通过解谜获得的经验值达到一定的极限，就让ta等级提升游戏目标：玩家游戏等级达到一定等级时，会给ta相应奖励(例如：一个奖杯)
*/ 
/*代码实现应该有三个函数：1. 更新玩家经验值2. 检查是否有足够的经验值确保玩家升级3. 玩家每提升一级，给ta相应的礼品
*/
/*设计思路：1. 从main函数入手，写一些基础性的内容(例如：定义玩家初始经验值和等级)2. 考虑函数如何设计(根据实际需求明确函数是否需要返回值以及返回值类型、函数参数)3. 设计函数过程中，完善代码逻辑(例如：多少经验值可以升级？游戏最高等级是多少？宝藏提示的数量有多少？)4. 宝藏提示函数(用到了表驱动法)：所有玩家在升到相同等级时，获得的宝藏全都相同，因此函数前面可以写一个const函数里用static的原因：函数里所有的东西都早已固定好，不需要每次升级都把函数重新定义一遍
*/#include<stdio.h>
#include<inttypes.h>
#include<stdbool.h>#define MAX_LEVEL 10
#define EXP_PER_LEVEL 100
#define HINTS_COUNT 10void increase_exp(int32_t* exp, int32_t increment);
bool check_level_up(int32_t* exp, int32_t* level);
const char* get_treasure_hint (int32_t level);
int main() {// 初始经验值和等级int32_t player_exp = 0;int32_t player_level = 1;// 玩家解谜获得经验值increase_exp(&player_exp, 75);increase_exp(&player_exp, 100);// 当前玩家是否可以升级(其实每次经验值增加后都应该进行这个判断)if (check_level_up(&player_exp, &player_level)) {// 获得相应提示printf("%s\n", get_treasure_hint(player_level));}else {printf("经验值不足，无法升级!\n");}return 0;}
void increase_exp(int32_t* exp, int32_t amount) {*exp += amount;
}bool check_level_up(int32_t* exp, int32_t* level) {while (*exp >= EXP_PER_LEVEL && *level < MAX_LEVEL) {*exp -= EXP_PER_LEVEL;(*level)++;printf("恭喜您的等级升到了%" PRId32 "级\n", *level);return true;}return false;
}const char* get_treasure_hint(int32_t level) {static const char* hints[HINTS_COUNT] = {"提示一：宝藏在...","提示二：宝藏在...","提示三：宝藏在...",// ......};if (level > 0 && level <= HINTS_COUNT) {return hints[(size_t)level - 1];}return "未知提示：请确保你的等级在有效范围内才能解锁宝藏提示";
}

12. 案例四：更新分数

游戏里经常会有一些模块：更新分数、比较分数、分数倍增等
仿写时出现的问题：分数比较模块返回值写成 “return (int32_t)(*player1_score > *player2_score) ? *player1_score : *player2_score” ，多加了 * 号

#include<stdio.h>
#include<inttypes.h>void update_score(int32_t* player_score, int32_t points);
int32_t* compare_score(int32_t* player1_score, int32_t* player2_score);
void double_score(int32_t* player_score);int main(void){int32_t player1_score = 100;int32_t player2_score = 150;// 更新分数update_score(&player1_score, 20);// 比较分数int32_t* higher_score = compare_score(&player1_score, &player2_score);printf("higher score: %" PRId32 "\n", *higher_score);// 分数倍增double_score(&player2_score);return 0;
}void update_score(int32_t* player_score, int32_t points){*player_score += points;printf("updated score: %" PRId32 "\n", *player_score);
}int32_t* compare_score(int32_t* player1_score, int32_t* player2_score){return (int32_t)(*player1_score > *player2_score) ? player1_score : player2_score;
}void double_score(int32_t* player_score){*player_score *= 2;printf("score after multiplication: %" PRId32 "\n", *player_score);
}

13. 案例五：收藏奖杯(char*可以保存字符串)

① 游戏中的用途：添加成就、显示所有成就效果
② const在函数参数中的用途：防止函数内部被有意或无意地修改(变量被声明为const意为该变量在今后仅可读，不可以被修改，即可读不可写)；保护传入的数据
③ 指针变量不仅可以保存地址，也可以保存字符串

#include<stdio.h>#define MAX_ACHIEVEMENT_COUNT 10
// 此处往数组里添加元素的方式类似于面向对象编程里的接口设计
const char* achievements[MAX_ACHIEVEMENT_COUNT];
void add_achievement(const char* new_achievement);
size_t achievement_count = 0;void print_achievements();int main(void) {add_achievement("完成第一个挑战奖杯");add_achievement("找到了所有的隐藏宝箱");print_achievements();return 0;
}void add_achievement(const char* new_achievement) {if (achievement_count < MAX_ACHIEVEMENT_COUNT) {achievements[achievement_count++] = new_achievement;printf("已添加新成就：%s\n", new_achievement);}else {printf("成就数组已满，无法添加新的成就！\n");}
}void print_achievements() {printf("显示所有已有成就：\n");for (size_t i = 0; i < achievement_count; ++i) {printf("%zu: %s\n", i + 1, achievements[i]);}
}

14. 内容出处

我是从p165地址这一小结开始看的指针这一部分
        虽然很早就学过c语言了，但是学的效果用四个字评价就是“一坨狗屎”。前几天我在听frank的数据结构的课程，听完了链表这一部分，原本想着理解了它的内核及应用场景后，代码部分应该也就不成问题了，其实一切本该如此，但是我突然发现我还是写不出来，基础知识部分太差劲了，例如：我只是知道有指针这个东西，但是让我具体解释，我真的会傻眼。虽然之前在学c语言的时候，也专门听过指针这部分的网课，但怎么说呢，跟着up主把代码敲了一遍(那代码我现在还有，但是那次写完之后再也没看过🤣)，该不懂还是不懂，甚至于当时刷题看见指针这个标签就会直接跳过。