Skip to content

第 7 章:函数(上):定义与调用 ​

知识链位置:第 0~6 章讲了环境、变量、运算符、输入输出、#include、条件和循环,已经能写出完整的单段程序。本章开始把程序拆成一块块可以重复使用的"函数",这是组织代码的第一步。

本章能学到什么 ​

  • 从初中一次函数 y=x+1 理解"输入、规则、输出"的确定对应
  • C++ 函数的定义与调用,以及函数的四个零件
  • 多个参数、返回值参与继续计算
  • 为什么要有函数:不重复、好修改、好读懂
  • C++ 的规定:函数先声明后使用;main 函数的特殊地位

从一个游戏场景说起 ​

想象一个扑克牌小游戏。每一局开始要"发牌",玩家每次赢牌要"计分"。这两个动作在一局游戏里会出现很多次:发牌五次、计分十几次都很正常。

如果每用一次就把同样的代码抄一遍,会出现两个问题:程序变得很长;哪天发牌规则改了,要找到每一处抄写的地方挨个改,漏掉一处就出 bug。

程序需要一个办法:把一段动作只写一次,起一个名字,用到的时候喊这个名字。这个办法就是函数。

回到数学课:一次函数 ​

初中数学里学过函数,比如:

y=x+1

它包含三件事:

部分含义在 y=x+1 里
输入交给函数的东西x
规则对输入做什么处理加 1
输出算出来的结果y

x=2 时 y=3,x=5 时 y=6。同一个输入永远得到同一个输出。这种"确定的对应关系"就是函数的核心。

数学里还有 f(x) 这种写法,f 是函数的名字,括号里的 x 是输入。看到 f(2),意思是"把 2 交给 f,按规则算出结果"。编程里的函数调用写法就是从这儿来的。

编程里的函数也是这三件事 ​

编程里的函数和数学函数结构相同,只是换了名字:

数学里的说法编程里的说法
输入参数(parameter)
规则函数体里的代码
输出返回值(return value)

下面写一个 C++ 函数,它和 y=x+1 完全对应:

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
6

int 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,表示"没有返回值"。

调用的写法是统一的:函数名加括号,括号里放参数,没有参数就留空。调用一次,函数体就跑一遍。

参数可以有多个 ​

数学里有二元函数,比如 z=x+y。编程里的函数同样可以收多个参数,用逗号隔开:

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
22

addOne(addOne(0)) 和数学里的复合函数 f(f(x)) 是同一个意思:先算里面的,把结果交给外面。

为什么要有函数 ​

好处说明
不重复同一段代码只写一遍,用的时候喊名字
好修改规则变了只改函数这一处,所有调用同时生效
好读懂函数名说明意图,读 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 分
公布赢家

名字本身就是说明。这是函数带来的阅读能力。

给函数起个好名字 ​

函数名是给人看的。好的名字让人不看函数体也知道它做什么:

好名字差名字原因
addScoreas看得出是"加分"
dealCardfunc1看得出是"发牌"
biggermyFunc看得出是"比大小"

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
返回 intreturn 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 就交还整数
括号里参数个数不对编译报参数不匹配定义收几个,调用给几个

动手实验 ​

  1. 写函数 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
  1. 写 void 函数 printLine(),打印一行 20 个星号。在 main 中调用 3 次,组成三条分隔线。
💡 查看答案
cpp
#include <iostream>
using namespace std;

void printLine() {
  cout << "********************" << endl;
}

int main() {
  printLine();
  printLine();
  printLine();
  return 0;
}
text
********************
********************
********************
  1. 把第 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程序的入口,从它开始执行

下一章深入函数的三个细节:参数怎么传、返回值怎么交还、变量在什么范围内有效。