深色模式
第 8 章:函数(下):参数、返回值、作用域
知识链位置:第 7 章讲了函数的定义与调用,本章深入函数的三个细节:参数怎么传、返回值怎么交还、变量在什么范围内有效。
本章能学到什么
- 形参与实参的区别,实参可以是表达式
return之后函数立刻结束- 局部变量与全局变量,用"教室里的座位号"理解作用域
- 【跨语言对照】声明与定义分离 vs
def即定义;值传递 vs 引用传递;默认参数
形参与实参
调用函数时,参数在两处出现:
| 名字 | 位置 | 含义 |
|---|---|---|
| 形参(形式参数) | 定义函数时括号里写的名字 | 一个占位符,等待被填入 |
| 实参(实际参数) | 调用函数时括号里给的值 | 真正填进去的内容 |
cpp
#include <iostream>
using namespace std;
// x 是形参:定义时还不知道它是多少
int addOne(int x) {
return x + 1;
}
int main() {
cout << addOne(2) << endl; // 2 是实参:真正传进去的值
int score = 5;
cout << addOne(score) << endl; // score 也是实参
return 0;
}text
3
6可以把形参看成作业本上的"姓名:______",实参是具体填上去的那个名字。定义时只有空位,调用时才填内容。
实参不一定是一个现成的数,任何能算出结果的表达式都可以当实参:
cpp
#include <iostream>
using namespace std;
int addOne(int x) {
return x + 1;
}
int main() {
cout << addOne(1 + 1) << endl; // 实参是算式:先算 1+1,再传入 2
cout << addOne(addOne(0)) << endl; // 实参是另一次调用
return 0;
}text
3
2规则是:先把实参算成一个值,再把这个值填进形参。和数学里"代入"完全相同。
实参按位置与形参一一对应,这是参数传递的默认规则。记住"定义时的顺序"和"调用时的顺序"必须一致,顺序错了,值就填错了位置。
返回值:return 之后函数结束
return 做两件事:把结果交还给调用者;让函数立刻结束。return 后面的代码不会执行。
cpp
#include <iostream>
using namespace std;
int checkScore(int score) {
if (score >= 60) {
return 1; // 及格,返回 1,函数到此结束
}
return 0; // 只有没及格的才会走到这里
}
int main() {
cout << checkScore(80) << endl; // 1
cout << checkScore(45) << endl; // 0
return 0;
}text
1
0score = 80 时,第一个 return 执行,函数立即交还 1 并结束,后面的 return 0; 不会执行。利用这个特点,可以在函数中间随时"交卷离场"。
void 函数没有结果可交还,但也可以用 return;(不带值)提前结束:
cpp
#include <iostream>
using namespace std;
void printPositive(int n) {
if (n <= 0) {
return; // 不是正数,直接结束
}
cout << n << endl;
}
int main() {
printPositive(5); // 打印 5
printPositive(-3); // 什么也不打印
return 0;
}text
5作用域:教室里的座位号
学校里每个班都有自己的"1 号"。一班的 1 号和二班的 1 号是两个不同的人,互相不影响;走出教室,"1 号"这个说法就没有意义了。
函数就像教室,函数里定义的变量就像教室里的座位号:
| 概念 | 教室类比 | 编程里的规则 |
|---|---|---|
| 局部变量 | 本班的座位号 | 只在函数内部有效,出了函数就消失 |
| 同名不冲突 | 一班 1 号和二班 1 号互不相干 | 两个函数可以有同名局部变量 |
| 全局变量 | 全校统一的工号 | 定义在所有函数之外,处处可用 |
cpp
#include <iostream>
using namespace std;
int schoolId = 100; // 全局变量:全校统一
void classA() {
int seat = 1; // 一班的局部变量
cout << "一班 seat=" << seat << ", 工号=" << schoolId << endl;
}
void classB() {
int seat = 2; // 二班的局部变量,与一班互不影响
cout << "二班 seat=" << seat << ", 工号=" << schoolId << endl;
}
int main() {
classA();
classB();
// cout << seat; // 错误:seat 只在自己的"教室"里有效
return 0;
}text
一班 seat=1, 工号=100
二班 seat=2, 工号=100两个 seat 互不干扰;schoolId 在两个函数里都能用。一般优先用局部变量,全局变量只放真正需要处处共享的东西——全局变量谁都能改,改错了不容易查到是谁改的。
作用域还能套得更小。循环的花括号也是一间"小教室":
cpp
#include <iostream>
using namespace std;
int main() {
for (int i = 0; i < 3; i++) {
int doubled = i * 2; // 只在本次循环的花括号里有效
cout << doubled << endl;
}
// cout << doubled; // 错误:出了花括号,doubled 就消失了
return 0;
}text
0
2
4规律是:变量在它被定义的那层花括号里有效,出了这层花括号就消失。
【跨语言对照】声明、传参与默认参数
本质问题
同一件事,两种语言各自怎么处理?这里看三个问题:函数要不要先"预告"、参数传进去的是复制还是本体、参数能不能有默认值。
各自做法
问题一:函数声明与定义分离
| C++ | Python | |
|---|---|---|
| 预告机制 | 有:声明(分号结尾,无函数体) | 无:def 即完整定义 |
| 定义位置 | 可放在调用之后,配合声明 | 必须在调用之前执行到 |
| 大规模组织 | 声明放进头文件 .h,多人共享 | 函数写进 .py,用 import 引入 |
第 4 章讲过的 #include <iostream>,本质就是把 iostream 头文件里的一堆函数声明粘贴进来,所以 cout 才能用。自己写头文件也是同一做法(下面示意三个文件的内容,分别保存):
cpp
// 文件 math_utils.h:只放声明
int addOne(int x);
// 文件 math_utils.cpp:放定义
int addOne(int x) {
return x + 1;
}
// 文件 main.cpp:包含头文件后就能调用
#include <iostream>
#include "math_utils.h"
using namespace std;
int main() {
cout << addOne(2) << endl;
return 0;
}编译时把两个 .cpp 一起交给 g++:g++ main.cpp math_utils.cpp,输出 3。
Python 的对应做法是把函数写进另一个 .py 文件,再 import 进来(第 4 章讲过 import)。def 执行到的那一刻,函数就存在了,没有"声明"这个中间步骤。
问题二:值传递与引用传递
| C++ | Python | |
|---|---|---|
| 默认行为 | 值传递:形参是实参的复制 | 传入的是对象本身,能否改动取决于对象类型 |
| 改原数据的方式 | 引用传递:参数类型写成 int &x | 传入可变对象(如列表),在函数内修改其内容 |
| 典型现象 | int &x 改了,main 里的变量跟着变 | 列表在函数内被 append,函数外看得到 |
C++ 实验,对比值传递与引用传递:
cpp
#include <iostream>
using namespace std;
void byValue(int x) { // 值传递:x 是复制品
x = 100; // 只改了复制品
}
void byRef(int &x) { // 引用传递:x 就是本尊
x = 100; // 改了本尊
}
int main() {
int a = 1, b = 1;
byValue(a); // a 不会变
byRef(b); // b 会被改成 100
cout << "a=" << a << endl;
cout << "b=" << b << endl;
return 0;
}text
a=1
b=100Python 对照实验,对比不可变对象与可变对象:
python
def change_num(x): # x 是整数(不可变对象)
x = 100 # 只是让 x 指向新数,外面的 a 不受影响
def change_list(lst): # lst 是列表(可变对象)
lst.append(100) # 修改列表本身,外面看得到
a = 1
nums = [1]
change_num(a)
change_list(nums)
print("a=", a)
print("nums=", nums)text
a= 1
nums= [1, 100]两段实验的现象一致:数字传进去,函数内的修改带不出来;换一种"能改本体"的方式(C++ 的 &,Python 的列表),修改就带出来了。
问题三:默认参数
调用时经常给同一个值,可以给参数设默认值,调用时省略它。
| C++ | Python | |
|---|---|---|
| 写法 | void greet(string name = "同学") | def greet(name="同学") |
| 省略效果 | greet() 等价于 greet("同学") | greet() 等价于 greet("同学") |
| 位置限制 | 默认参数靠右放 | 默认参数靠右放 |
cpp
#include <iostream>
#include <string>
using namespace std;
void greet(string name = "同学") { // 默认参数
cout << "你好," << name << "!" << endl;
}
int main() {
greet(); // 用默认值
greet("小明"); // 用传入的值
return 0;
}text
你好,同学!
你好,小明!python
def greet(name="同学"): # 默认参数
print("你好," + name + "!")
greet() # 用默认值
greet("小明") # 用传入的值text
你好,同学!
你好,小明!"默认参数靠右放"的意思是:有默认值的参数要排在没默认值的参数后面。greet(string name = "同学", int times) 是错的,因为省略 name 后没法按位置对应。
为什么设计不一样
C++ 在编译期要把每个函数的调用检查清楚,所以需要声明机制:编译器读到调用时,先凭一句声明确认"这个函数存在、参数类型对得上",具体定义可以稍后再看。头文件就是这个机制在大项目里的组织方式。
Python 边读边执行,函数的存在与否取决于 def 是否执行过,天然不需要单独的声明。传参上,C++ 默认复制一份以明确"谁的数据归谁";Python 一律传入对象本身,用"可变/不可变"区分能不能改。两边的默认参数语法不同,但目的相同:让常见调用少写字。
对照姊妹册:《Python 从入门到精通》第 8 章。
没有参数的函数也可以有返回值
参数和返回值是两回事,可以自由组合。一个不收参数的函数,照样能交还结果:
cpp
#include <iostream>
using namespace std;
int getFullMark() { // 不收参数
return 100; // 但交还满分
}
int main() {
int full = getFullMark();
cout << "满分是 " << full << endl;
return 0;
}text
满分是 100getFullMark 这种"无参数有返回值"的函数,相当于一个会自己计算的常量:调用一次,得到一个确定的结果。把满分、税率这类"全程序统一的数"放进函数里,改规则时只改一处。
四种组合都存在:有参数有返回值(addOne)、有参数无返回值(addScore)、无参数有返回值(getFullMark)、无参数无返回值(dealCard)。按函数要做的事情选择组合。
函数里调用另一个函数
函数之间可以互相调用,像接力。main 喊 showResult,showResult 再喊 addOne:
cpp
#include <iostream>
using namespace std;
int addOne(int x) {
return x + 1;
}
void showResult(int x) {
int r = addOne(x); // 函数里再调用函数
cout << x << " 加 1 等于 " << r << endl;
}
int main() {
showResult(5);
showResult(9);
return 0;
}text
5 加 1 等于 6
9 加 1 等于 10复杂程序就是这样搭起来的:大函数调用小函数,小函数调用更小的函数,每个函数只做一件小事。
什么时候才用全局变量
全局变量处处可见、处处可改,方便但危险。一个经验判断:这个数据是不是真的需要被很多函数共享?
| 情况 | 建议 |
|---|---|
| 数据只在一个函数里用 | 局部变量 |
| 数据要交给另一个函数 | 用参数传,用 return 收 |
| 全校级别的常量(如满分 100) | 可以用全局变量 |
| 想让函数偷偷改掉某个值 | 不要用全局变量,改用引用参数 |
局部变量:每次调用都是新的一轮
函数里的局部变量,在每次调用时重新出生,调用结束就消失。两次调用之间,局部变量不会"记住"上次的值:
cpp
#include <iostream>
using namespace std;
void countOnce() {
int count = 0; // 每次调用都重新从 0 开始
count++;
cout << count << endl;
}
int main() {
countOnce(); // 1
countOnce(); // 还是 1,不是 2
countOnce(); // 还是 1
return 0;
}text
1
1
1三次打印都是 1。因为每次进入 countOnce,count 都是新出生的,和上一次调用的 count 没有任何关系。想跨调用记住东西,就把结果 return 出来,由调用方保管。
用 return 提前结束做判断
判断"一个数是不是两位数",利用"return 之后函数立刻结束",可以写得很直接:
cpp
#include <iostream>
using namespace std;
int isTwoDigit(int n) {
if (n < 10) {
return 0; // 太小,直接判 0
}
if (n > 99) {
return 0; // 太大,直接判 0
}
return 1; // 走到这里说明是两位数
}
int main() {
cout << isTwoDigit(5) << endl; // 0
cout << isTwoDigit(42) << endl; // 1
cout << isTwoDigit(120) << endl; // 0
return 0;
}text
0
1
0每个 return 守住一种情况,后面的代码只处理"剩下的可能"。这种写法叫"提前返回",读的时候从上往下逐个排除,思路清楚。
形参也是局部变量
形参 x 是函数这间"教室"里的一个座位:调用时它被填上值,函数结束时它消失。所以形参遵守局部变量的一切规则——两个函数的形参同名,互不影响。
cpp
#include <iostream>
using namespace std;
int addOne(int x) { // 这个 x 属于 addOne
return x + 1;
}
int triple(int x) { // 这个 x 属于 triple,同名不冲突
return x * 3;
}
int main() {
cout << addOne(2) << endl; // 3
cout << triple(2) << endl; // 6
return 0;
}text
3
6return 的值就是数学里的函数值
数学里写 addOne(2) 算出的 3 也是函数值,只是交还的方式叫 return。
| 数学 | C++ |
|---|---|
int addOne(int x) { return x + 1; } | |
addOne(2) | |
addOne(2) 交还的 3 |
函数值和普通值一样用:能打印、能赋值、能继续运算。这正是"函数可以像积木一样拼接"的原因——一个函数的输出,可以直接当另一个函数的输入。
常见错误
| 错误写法 | 后果 | 正确做法 |
|---|---|---|
| 想改实参却用值传递 | 函数外看不到变化 | 参数类型加 & 用引用传递 |
return 后还写代码 | 那些代码永远不会执行 | 提前结束的逻辑放 return 前 |
| 在函数外用局部变量 | 编译报"未声明" | 需要的结果用 return 交还 |
| 默认参数放左边 | 编译报错 | 默认参数一律靠右 |
动手实验
- 写函数
isPass(int score),分数不低于 60 返回1,否则返回0。在main中用循环检查 45、60、90 三个分数并打印结果。
💡 查看答案
cpp
#include <iostream>
using namespace std;
int isPass(int score) {
if (score >= 60) {
return 1; // 及格,立刻结束函数
}
return 0;
}
int main() {
int scores[3] = {45, 60, 90};
for (int i = 0; i < 3; i++) {
cout << scores[i] << " 分:" << isPass(scores[i]) << endl;
}
return 0;
}text
45 分:0
60 分:1
90 分:1- 写引用传递函数
swapTwo(int &a, int &b),交换两个变量的值。在main中交换x=3、y=7并打印。
💡 查看答案
cpp
#include <iostream>
using namespace std;
void swapTwo(int &a, int &b) { // 引用传递才能改到本尊
int temp = a;
a = b;
b = temp;
}
int main() {
int x = 3, y = 7;
swapTwo(x, y);
cout << "x=" << x << ", y=" << y << endl;
return 0;
}text
x=7, y=3如果去掉 & 改成值传递,交换的只是复制品,x 和 y 不会变。
- 写函数
power(int base, int n = 2),计算base的n次方,n默认是 2。调用power(5)和power(2, 3)并打印。
💡 查看答案
cpp
#include <iostream>
using namespace std;
int power(int base, int n = 2) { // n 默认 2
int result = 1;
for (int i = 0; i < n; i++) {
result *= base;
}
return result;
}
int main() {
cout << power(5) << endl; // 5 的 2 次方
cout << power(2, 3) << endl; // 2 的 3 次方
return 0;
}text
25
8本章小结
| 概念 | 一句话 |
|---|---|
| 形参 / 实参 | 定义时的占位符 / 调用时填的值 |
return | 交还结果,函数立刻结束 |
| 局部变量 | 只在函数的花括号里有效 |
| 全局变量 | 所有函数之外定义,处处可用 |
| 声明与定义 | 声明只写样子,定义写出内容 |
| 值传递 / 引用传递 | 复制一份 / 操作本尊(int &x) |
| 默认参数 | 调用时可省略的参数,靠右放 |
下一章处理文字数据:字符串。
