Skip to content

第 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
0

score = 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=100

Python 对照实验,对比不可变对象与可变对象:

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
满分是 100

getFullMark 这种"无参数有返回值"的函数,相当于一个会自己计算的常量:调用一次,得到一个确定的结果。把满分、税率这类"全程序统一的数"放进函数里,改规则时只改一处。

四种组合都存在:有参数有返回值(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
6

return 的值就是数学里的函数值 ​

数学里写 f(2)=3,3 叫"函数值"。编程里 addOne(2) 算出的 3 也是函数值,只是交还的方式叫 return。

数学C++
f(x)=x+1int addOne(int x) { return x + 1; }
f(2)addOne(2)
f(2)=3 中的 3addOne(2) 交还的 3

函数值和普通值一样用:能打印、能赋值、能继续运算。这正是"函数可以像积木一样拼接"的原因——一个函数的输出,可以直接当另一个函数的输入。

常见错误 ​

错误写法后果正确做法
想改实参却用值传递函数外看不到变化参数类型加 & 用引用传递
return 后还写代码那些代码永远不会执行提前结束的逻辑放 return 前
在函数外用局部变量编译报"未声明"需要的结果用 return 交还
默认参数放左边编译报错默认参数一律靠右

动手实验 ​

  1. 写函数 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
  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 不会变。

  1. 写函数 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)
默认参数调用时可省略的参数,靠右放

下一章处理文字数据:字符串。