DAY7-预习
2026-07-17 20:15:07
发布于：广东
64阅读
0回复
0点赞
📦 C++ 函数与指针 · 课前预习笔记
明天要学的东西叫 “函数”和“指针” ——说白了就是让程序学会分工合作，把大任务拆成小任务，还能直接操作内存地址，写出更灵活、更强大的代码！
一、先搞懂：什么是函数？
1. 生活类比
你做一道番茄炒蛋：
- 没有函数：把所有步骤都写在 main 里，又长又乱
- 有函数：把“切番茄”、“打鸡蛋”、“炒菜”分别写成小模块，main 里只需要调用它们
// 没有函数（全挤在main里）
int main() {
// 切番茄的代码...
// 打鸡蛋的代码...
// 炒菜的代码...
// 装盘的代码...
return 0;
}
// 有函数（分工明确）
void 切番茄() { ... }
void 打鸡蛋() { ... }
void 炒菜() { ... }
int main() {
切番茄();
打鸡蛋();
炒菜();
return 0;
}
2. 函数的好处
| 好处 | 说明 |
|---|---|
| 代码复用 | 同一段代码可以反复调用，不用重复写 |
| 分工明确 | 每个函数只做一件事，逻辑清晰 |
| 容易修改 | 改一个函数就行，不影响其他部分 |
| 方便调试 | 哪里出错就查哪个函数 |
二、函数的定义与调用
1. 函数的定义格式
返回值类型 函数名(参数列表) {
// 函数体（要执行的代码）
return 返回值;
}
2. 函数的四个部分
| 部分 | 说明 | 例子 |
|---|---|---|
| 返回值类型 | 函数返回什么类型的数据 | int、double、void（无返回值） |
| 函数名 | 给函数起个名字，见名知意 | add、max、printHello |
| 参数列表 | 函数需要什么数据 | int a, int b |
| 函数体 | 具体做什么事 | { return a + b; } |
3. 完整例子
#include <iostream>
using namespace std;
// 定义函数：求两个整数的和
int add(int a, int b) {
return a + b; // 返回 a + b 的结果
}
// 定义函数：输出一行欢迎语（无返回值）
void printWelcome() {
cout << "欢迎使用本程序！" << endl;
}
int main() {
printWelcome(); // 调用函数，输出欢迎语
int x = 3, y = 5;
int result = add(x, y); // 调用函数，把结果存到result里
cout << x << " + " << y << " = " << result << endl;
// 输出：3 + 5 = 8
return 0;
}
4. 函数的调用流程
main() 开始
↓
调用 printWelcome() → 执行 printWelcome 的代码 → 回到 main()
↓
调用 add(3, 5) → 执行 add 的代码 → 返回 8 → 回到 main()
↓
main() 结束
💡 记住：函数不调用就不执行！定义函数只是告诉电脑“我有这个功能”，调用才是真正使用它。
三、作用域（Scope）
1. 什么是作用域？
作用域 = 变量的“势力范围”——变量在哪个范围里有效。
2. 局部变量 vs 全局变量
#include <iostream>
using namespace std;
int globalVar = 10; // 全局变量：在整个程序里都能用
void func() {
int localVar = 5; // 局部变量：只在 func() 里面有效
cout << globalVar; // ✅ 能访问全局变量
cout << localVar; // ✅ 能访问自己的局部变量
}
int main() {
int localVar = 20; // 这是 main() 的局部变量，和 func() 里的不是同一个！
cout << globalVar; // ✅ 能访问全局变量（输出10）
cout << localVar; // ✅ 能访问自己的局部变量（输出20）
// cout << func里的localVar; // ❌ 访问不到！那是 func() 私有的
return 0;
}
3. 作用域规则总结
| 变量类型 | 定义位置 | 作用范围 | 特点 |
|---|---|---|---|
| 全局变量 | 所有函数外面 | 整个程序都能用 | 任何地方都能访问和修改 |
| 局部变量 | 函数内部 | 只能在自己函数里用 | 函数结束就销毁 |
| 形参 | 函数参数列表里 | 只能在自己函数里用 | 相当于局部变量 |
4. 名字冲突（同名变量的优先级）
int a = 10; // 全局变量
void func() {
int a = 20; // 局部变量（和全局变量同名）
cout << a; // 输出 20（局部变量优先！）
cout << ::a; // 输出 10（用 :: 强行访问全局变量）
}
💡 记住：局部变量会“遮蔽”同名的全局变量。就近原则！
四、函数的参数传递
1. 值传递（传值）
概念：把参数的值复制一份传给函数，函数里改的是副本，不影响原来的变量。
void swap(int a, int b) {
int temp = a;
a = b;
b = temp;
// 这里交换的是副本，不影响外面的变量
}
int main() {
int x = 3, y = 5;
swap(x, y);
cout << x << " " << y; // 还是输出 3 5（没变！）
return 0;
}
💡 值传递就像复印了一份文件，你改复印件，原件不受影响。
2. 地址传递（传指针）
概念：把变量的内存地址传给函数，函数通过地址直接操作原来的变量。
void swap(int* a, int* b) { // 接收地址
int temp = *a; // *a 就是取 a 指向的值
*a = *b;
*b = temp;
// 这里操作的是原来的变量！
}
int main() {
int x = 3, y = 5;
swap(&x, &y); // &x 是取 x 的地址
cout << x << " " << y; // 输出 5 3（真的交换了！）
return 0;
}
💡 地址传递就像把房子地址告诉了别人，别人可以直接去你家里改造。
3. 值传递 vs 地址传递
| 对比项 | 值传递 | 地址传递（指针） |
|---|---|---|
| 传递的是什么 | 数据的副本 | 数据的地址 |
| 会不会改变原值 | ❌ 不会 | ✅ 会 |
| 写法 | func(a, b) |
func(&a, &b) |
| 形参类型 | int a |
int* a |
| 访问数据 | 直接用 a |
用 *a |
五、数学函数（cmath 库）
1. 需要头文件
#include <cmath> // 数学工具箱
2. 常用数学函数
| 函数 | 功能 | 例子 |
|---|---|---|
max(a, b) |
取较大值 | max(3, 5) = 5 |
min(a, b) |
取较小值 | min(3, 5) = 3 |
pow(a, b) |
计算 aᵇ | pow(2, 3) = 8 |
abs(x) |
取绝对值 | abs(-5) = 5 |
sqrt(x) |
开平方 | sqrt(81) = 9 |
3. 例子
#include <iostream>
#include <cmath>
using namespace std;
int main() {
int a = 3, b = 7;
cout << max(a, b) << endl; // 7
cout << pow(2, 10) << endl; // 1024
cout << abs(-10) << endl; // 10
cout << sqrt(100) << endl; // 10
// 计算两点距离
double x1 = 1, y1 = 1, x2 = 4, y2 = 5;
double dist = sqrt(pow(x2 - x1, 2) + pow(y2 - y1, 2));
cout << dist << endl; // 5
return 0;
}
六、指针（了解）
1. 什么是指针？
指针 = 存储地址的变量
我们平时定义的变量存的是数据，指针变量存的是数据在内存中的地址。
int a = 10; // a 里存的是数字 10
int* p = &a; // p 里存的是 a 的地址
2. 指针相关的符号
| 符号 | 含义 | 例子 |
|---|---|---|
& |
取地址：获取变量的地址 | &a 得到 a 的地址 |
* |
解引用：获取地址里存的值 | *p 得到 p 指向的值 |
3. 指针的基本使用
int a = 10;
int* p = &a; // p 指向 a
cout << a; // 输出 10（直接取值）
cout << &a; // 输出 0x7ff...（a的地址）
cout << p; // 输出 0x7ff...（p存的是a的地址）
cout << *p; // 输出 10（通过p找到a的值）
*p = 20; // 通过指针修改 a 的值
cout << a; // 输出 20（a 真的变了！）
4. 指针有什么用？
| 用途 | 说明 |
|---|---|
| 函数传参 | 让函数能修改外面的变量（如 swap 函数） |
| 动态内存分配 | 程序运行时才决定要分配多少内存 |
| 数组操作 | 数组名本身就是指针，可以用指针遍历数组 |
| 数据结构 | 链表、树等数据结构必须用指针 |
5. 指针和数组的关系
int a[5] = {10, 20, 30, 40, 50};
int* p = a; // 数组名就是首地址，相当于 &a[0]
cout << *p; // 输出 10（a[0]）
cout << *(p+1); // 输出 20（a[1]）
cout << *(p+2); // 输出 30（a[2]）
// 用指针遍历数组
for (int i = 0; i < 5; i++) {
cout << *(p + i) << " "; // 输出 10 20 30 40 50
}
📝 快速记忆卡
| 概念 | 一句话总结 |
|---|---|
| 函数 | 把代码打包成小模块，可以重复调用 |
| 返回值 | 函数执行完给调用者的结果 |
| 参数 | 函数需要的数据，调用时传进去 |
| 作用域 | 变量的“势力范围”，不能随便访问别人的局部变量 |
| 全局变量 | 所有函数都能访问 |
| 局部变量 | 只能在自己函数里用 |
| 值传递 | 传副本，改了不影响原值 |
| 地址传递（指针） | 传地址，改了会影响原值 |
| 指针 | 存地址的变量，用 * 取值，用 & 取地址 |
🔥 预习小任务
-
下面这段代码会输出什么？
void func(int x) { x = 100; } int main() { int a = 5; func(a); cout << a; return 0; } -
指针
p指向变量a，怎么通过p修改a的值？ -
全局变量和局部变量同名时，谁优先？
明天上课带着这些问题来，效果翻倍！🚀
有帮助，赞一个