深色模式
第 7 章:函数(上):定义与调用
知识链位置:第 0~6 章讲了环境、变量、运算符、输入输出、#include、条件和循环,已经能写出完整的单段程序。本章开始把程序拆成一块块可以重复使用的"函数",这是组织代码的第一步。
本章能学到什么
- 从初中一次函数
理解"输入、规则、输出"的确定对应 - C++ 函数的定义与调用,以及函数的四个零件
- 多个参数、返回值参与继续计算
- 为什么要有函数:不重复、好修改、好读懂
- C++ 的规定:函数先声明后使用;
main函数的特殊地位
从一个游戏场景说起
想象一个扑克牌小游戏。每一局开始要"发牌",玩家每次赢牌要"计分"。这两个动作在一局游戏里会出现很多次:发牌五次、计分十几次都很正常。
如果每用一次就把同样的代码抄一遍,会出现两个问题:程序变得很长;哪天发牌规则改了,要找到每一处抄写的地方挨个改,漏掉一处就出 bug。
程序需要一个办法:把一段动作只写一次,起一个名字,用到的时候喊这个名字。这个办法就是函数。
回到数学课:一次函数
初中数学里学过函数,比如:
它包含三件事:
| 部分 | 含义 | 在 |
|---|---|---|
| 输入 | 交给函数的东西 | |
| 规则 | 对输入做什么处理 | 加 1 |
| 输出 | 算出来的结果 |
数学里还有 f 是函数的名字,括号里的 x 是输入。看到
编程里的函数也是这三件事
编程里的函数和数学函数结构相同,只是换了名字:
| 数学里的说法 | 编程里的说法 |
|---|---|
| 输入 | 参数(parameter) |
| 规则 | 函数体里的代码 |
| 输出 | 返回值(return value) |
下面写一个 C++ 函数,它和
cpp
#include <iostream>
using namespace std;
// 定义函数 addOne:输入一个整数,返回这个数加 1
int addOne(int x) {
int y = x + 1; // 规则:加 1
return y; // 输出结果
}
int main() {
cout << addOne(2) << endl; // 输入 2,输出 3
cout << addOne(5) << endl; // 输入 5,输出 6
return 0;
}text
3
6int addOne(int x) 这一行说明三件事:返回值是 int(整数),函数名叫 addOne,参数是一个 int,名字叫 x。return y; 把结果交还给调用它的地方,就像数学里"代入求值"得到的那个数。
对照姊妹册:《Python 从入门到精通》第 7 章 用 Python 写同一个函数。
函数的四个零件
一个 C++ 函数由四个零件组成,缺一不可:
| 零件 | 在 int addOne(int x) 里 | 作用 |
|---|---|---|
| 返回类型 | int | 说明结果是什么类型 |
| 函数名 | addOne | 调用时喊的名字 |
| 参数列表 | (int x) | 说明要收什么输入 |
| 函数体 | { ... } | 规则,真正干活的代码 |
没有输入的函数,参数列表写空括号 ()。没有输出的函数,返回类型写 void。下一节会看到这两种情况。
调用:函数不会自己跑
函数定义好之后不会自动执行。只有调用它——写上函数名、括号和参数——它才执行。调用可以发生任意多次,每次传入的参数可以不同。
回到游戏的例子,把"发牌"和"计分"各写成一个函数:
cpp
#include <iostream>
using namespace std;
// 发一张牌:不需要参数,也没有返回值
void dealCard() {
cout << "发一张牌" << endl;
}
// 计分:需要一个参数表示加多少分
void addScore(int points) {
cout << "加分 " << points << " 分" << endl;
}
int main() {
dealCard(); // 第一次发牌
dealCard(); // 第二次发牌
addScore(10); // 加 10 分
dealCard(); // 再发一张
addScore(20); // 加 20 分
return 0;
}text
发一张牌
发一张牌
加分 10 分
发一张牌
加分 20 分这里出现了 void。有的函数只做事、不交还结果,比如 dealCard 只是打印一行字。这种函数的返回类型写成 void,表示"没有返回值"。
调用的写法是统一的:函数名加括号,括号里放参数,没有参数就留空。调用一次,函数体就跑一遍。
参数可以有多个
数学里有二元函数,比如
cpp
#include <iostream>
using namespace std;
// 收两个整数,返回较大的那个
int bigger(int a, int b) {
if (a > b) {
return a;
}
return b;
}
int main() {
cout << bigger(3, 7) << endl; // 7
cout << bigger(9, 2) << endl; // 9
return 0;
}text
7
9调用时参数按位置一一对应:bigger(3, 7) 里 3 交给 a,7 交给 b。顺序不能乱,bigger(3, 7) 和 bigger(7, 3) 是两回事。
返回值可以继续参与计算
return 交还的结果是一个普通的值,可以赋给变量,也可以直接放进表达式继续算:
cpp
#include <iostream>
using namespace std;
int addOne(int x) {
return x + 1;
}
int main() {
int a = addOne(2); // 返回值存进变量:a = 3
int b = addOne(addOne(0)); // 嵌套调用:addOne(0) 得 1,再 addOne(1) 得 2
cout << a << endl;
cout << b << endl;
cout << addOne(10) * 2 << endl; // 返回值直接乘 2
return 0;
}text
3
2
22addOne(addOne(0)) 和数学里的复合函数
为什么要有函数
| 好处 | 说明 |
|---|---|
| 不重复 | 同一段代码只写一遍,用的时候喊名字 |
| 好修改 | 规则变了只改函数这一处,所有调用同时生效 |
| 好读懂 | 函数名说明意图,读 main 像读一份提纲 |
举例:游戏规则改成"得分翻倍"。不用函数的话,要找到每一处加分代码修改;用了函数,只改 addScore 里的一行,所有调用它的地方自动使用新规则。
再看"好读懂"。下面这个程序不看函数内部,也知道它在做什么:
cpp
#include <iostream>
using namespace std;
void dealCard() {
cout << "发一张牌" << endl;
}
void addScore(int points) {
cout << "加分 " << points << " 分" << endl;
}
void showWinner() {
cout << "公布赢家" << endl;
}
int main() {
dealCard();
dealCard();
addScore(10);
showWinner();
return 0;
}text
发一张牌
发一张牌
加分 10 分
公布赢家名字本身就是说明。这是函数带来的阅读能力。
给函数起个好名字
函数名是给人看的。好的名字让人不看函数体也知道它做什么:
| 好名字 | 差名字 | 原因 |
|---|---|---|
addScore | as | 看得出是"加分" |
dealCard | func1 | 看得出是"发牌" |
bigger | myFunc | 看得出是"比大小" |
C++ 常用"小驼峰"写法:第一个单词全小写,后面每个单词首字母大写,如 addScore、showWinner。名字里不能有中文标点,不能以数字开头。
C++ 的规定:先声明,后使用
C++ 编译器从上往下读代码。读到一次函数调用时,它必须已经见过这个函数的名字,否则报错。
两种合法的安排:
| 做法 | 写法 |
|---|---|
| 定义在前 | 把整个函数写在调用之前 |
| 声明在前 | 调用之前先写一句声明,定义放在后面 |
前面的例子用的都是"定义在前"。下面演示"声明在前":
cpp
#include <iostream>
using namespace std;
void greet(); // 声明:告诉编译器有 greet 这个函数
int main() {
greet(); // 调用时编译器已经见过声明,合法
return 0;
}
void greet() { // 定义:函数的具体内容,可以放在后面
cout << "你好,欢迎来玩!" << endl;
}text
你好,欢迎来玩!声明以分号结尾,只描述函数的样子(返回类型、名字、参数),没有函数体。定义带花括号,写出函数真正做什么。
如果函数定义写在 main 后面又不加声明,编译器读到 greet(); 时会报告"greet 未声明"。加上一行声明就能通过。
main 函数的特殊地位
main 也是一个函数,但它是程序的入口。程序启动时,系统找到 main,从它的第一行开始执行;main 执行完,程序就结束了。
| 特点 | 说明 |
|---|---|
| 入口 | 程序从 main 开始运行 |
| 唯一 | 一个程序只能有一个 main |
| 返回 int | return 0; 表示程序正常结束 |
| 不调用别人也能跑 | 其他函数都是等被调用才执行 |
可以把程序想象成一节课:main 是老师,一进教室就开始讲课;其他函数是坐在座位上的同学,老师点到名字才站起来回答。
参数的类型要匹配
C++ 的函数声明里写明了每个参数的类型,调用时给的实参类型要对得上:
cpp
#include <iostream>
#include <string>
using namespace std;
void showInfo(string name, int age) { // 第 1 个参数是文字,第 2 个是整数
cout << name << "," << age << " 岁" << endl;
}
int main() {
showInfo("小明", 12); // 类型、顺序都对
// showInfo(12, "小明"); // 错误:类型和顺序对不上
return 0;
}text
小明,12 岁类型不匹配时编译器会直接报错,程序根本生不出来。这看着严格,实际是提前帮忙发现了错误。
函数与循环的组合
函数和循环可以套着用:函数负责"做一件事",循环负责"做很多遍"。打印一个星号三角形:
cpp
#include <iostream>
using namespace std;
// 打印一行 n 个星号
void printStars(int n) {
for (int i = 0; i < n; i++) {
cout << "*";
}
cout << endl;
}
int main() {
for (int i = 1; i <= 4; i++) {
printStars(i); // 第 i 行打印 i 个星号
}
return 0;
}text
*
**
***
****外层循环管"第几行",函数管"这一行怎么打"。分工清楚,各自都好读。
调用的执行过程
程序跑到一次调用时,发生了什么?分三步:
| 步骤 | 动作 |
|---|---|
| 1 | 把实参的值填进形参 |
| 2 | 跳到函数体,从头开始执行 |
| 3 | 遇到 return(或函数体结束),带着结果跳回调用处,继续往下走 |
用一段带打印的程序观察这个过程:
cpp
#include <iostream>
using namespace std;
int addOne(int x) {
cout << " 进入 addOne,x=" << x << endl;
return x + 1;
}
int main() {
cout << "调用前" << endl;
int r = addOne(2);
cout << "调用后,结果=" << r << endl;
return 0;
}text
调用前
进入 addOne,x=2
调用后,结果=3输出顺序说明:程序确实"跳进"函数里执行完,再"跳回"原来的位置继续往下走。调用几次,就跳进去几次。
void 函数:只做事,不交还
类比值日生:老师喊"小明擦黑板",小明做完就完了,不需要交还一个"结果"。void 函数就是这种"做事型"函数。
| 函数种类 | 类比 | 返回类型 |
|---|---|---|
| 计算型 | 问同学一道题,他给答案 | int、double 等 |
| 做事型 | 让值日生擦黑板,做完即止 | void |
计算型函数的结果可以继续参与运算;做事型函数没有结果,cout << dealCard(); 这种写法是错的,因为没有东西可打印。
不写函数会怎样
假设欢迎语要显示三次,不用函数的写法是复制三遍:
cpp
#include <iostream>
using namespace std;
int main() {
cout << "====================" << endl;
cout << " 欢迎来到单词接龙 " << endl;
cout << "====================" << endl;
cout << "====================" << endl;
cout << " 欢迎来到单词接龙 " << endl;
cout << "====================" << endl;
cout << "====================" << endl;
cout << " 欢迎来到单词接龙 " << endl;
cout << "====================" << endl;
return 0;
}用函数,同样的效果:
cpp
#include <iostream>
using namespace std;
void showWelcome() {
cout << "====================" << endl;
cout << " 欢迎来到单词接龙 " << endl;
cout << "====================" << endl;
}
int main() {
showWelcome();
showWelcome();
showWelcome();
return 0;
}text
====================
欢迎来到单词接龙
====================
====================
欢迎来到单词接龙
====================
====================
欢迎来到单词接龙
====================两个程序输出一样。区别在于:第一种写法里改欢迎语要改三处,第二种只改 showWelcome 一处。程序越长,这个差别越大。
一个小游戏的完整骨架
把本章的零件组合起来,看看一个游戏的"骨架程序"长什么样:
cpp
#include <iostream>
using namespace std;
void showWelcome() {
cout << "欢迎来到单词接龙" << endl;
}
void playRound(int round) {
cout << "第 " << round << " 回合开始" << endl;
}
void showScore(int score) {
cout << "当前得分:" << score << endl;
}
int main() {
showWelcome();
int score = 0;
for (int round = 1; round <= 3; round++) {
playRound(round);
score += 10; // 假设每回合都得 10 分
showScore(score);
}
cout << "游戏结束" << endl;
return 0;
}text
欢迎来到单词接龙
第 1 回合开始
当前得分:10
第 2 回合开始
当前得分:20
第 3 回合开始
当前得分:30
游戏结束读 main 就能看懂整个游戏的流程:欢迎、三回合、结束。每个回合的细节藏在各自的函数里。这就是函数带来的"提纲式"阅读体验。
常见错误
| 错误写法 | 后果 | 正确做法 |
|---|---|---|
调用时忘写括号 greet; | 函数没有执行 | 调用必须有括号 greet(); |
| 定义写在调用之后且无声明 | 编译报"未声明" | 定义提前,或先写声明 |
return 的类型与声明不符 | 编译报类型错误 | 返回 int 就交还整数 |
| 括号里参数个数不对 | 编译报参数不匹配 | 定义收几个,调用给几个 |
动手实验
- 写函数
triple(int x),返回x的 3 倍。在main中调用triple(4)和triple(7),打印结果。
💡 查看答案
cpp
#include <iostream>
using namespace std;
int triple(int x) {
return x * 3; // 规则:乘 3
}
int main() {
cout << triple(4) << endl; // 12
cout << triple(7) << endl; // 21
return 0;
}text
12
21- 写
void函数printLine(),打印一行 20 个星号。在main中调用 3 次,组成三条分隔线。
💡 查看答案
cpp
#include <iostream>
using namespace std;
void printLine() {
cout << "********************" << endl;
}
int main() {
printLine();
printLine();
printLine();
return 0;
}text
********************
********************
********************- 把第 2 题的
printLine定义移到main后面,先编译观察报错信息,再在main前面加一行声明修复它。
💡 查看答案
不加声明时,编译器报错大意是"printLine 未在此作用域中声明"。修复方法:
cpp
#include <iostream>
using namespace std;
void printLine(); // 声明在前
int main() {
printLine();
printLine();
printLine();
return 0;
}
void printLine() { // 定义在后
cout << "********************" << endl;
}输出与第 2 题相同。
本章小结
| 概念 | 一句话 |
|---|---|
| 函数 | 一段有名字的代码,喊名字就执行 |
| 参数 | 函数的输入,对应数学里的自变量 |
| 返回值 | 函数的输出,对应数学里的函数值 |
void | 没有返回值的标记 |
| 声明 | 提前告诉编译器函数的样子,分号结尾 |
main | 程序的入口,从它开始执行 |
下一章深入函数的三个细节:参数怎么传、返回值怎么交还、变量在什么范围内有效。
