普通函数：
参数、调用与返回。

上一章能在main中完成一次计数。现在，同样的计算要用于0、1和4三份输入：是复制三遍循环，还是给这段工作一个名字？这一章要解决的是：一次计算怎样接收输入、交出结果，再让调用它的地方继续执行？

先备是新03：控制流。继续使用前三章的编译流程、标量、算术、分支和普通循环。每个下载文件各有自己的main，分别编译运行；不要把本章14个文件一起交给一次链接。

六节预估8小时，包含阅读、预测和编码，仍未经真人试学校准。先沿着一次调用走完，再比较两次调用。前五节的小整数例子限定在−100到100，保证本章的加减、取负和除法结果可表示；两份计数函数另外明确0到100的输入合同。

04.1 定义与调用 · 预估90分钟

给一段计算起名字之后，程序何时才会执行它

你想把“得到下一个整数”用在不同位置。把几行代码放进花括号还不够：调用者需要知道它叫什么、要交什么进去、能得到什么。这一节先读函数的外形，再追踪控制从哪里离开、又回到哪里。

本章采用一套简单的命名方式：以小写英文字母开头，后续可以放字母、数字和内部下划线_，例如next、sum_before、count_even_before。下划线是名字的一部分，和减法符号-不同；sum_before是一个完整名字。关键字不能用作自己的名字，大小写不同也是不同名字。本章不采用以下划线开头或连续含两个下划线的名字；这是一套可直接使用的命名子集，不是全部C++标识符规则。

函数定义（function definition）给一段工作规定名字、输入和函数体。读int next(int value)：最前面的int是返回类型，表示正常交回的结果是一个整数；next是函数名；圆括号里的int value声明这次调用接收的整数形参（parameter）；随后花括号是函数体。这里的int value不要求你预先在main里创建同名变量。

next(4)是函数调用（function call）。括号中的4是这次实际提供的实参（argument）。调用表达式会得到函数交回的结果，因此能放在已有的初始化写法里：int result{next(4)};先完成调用，取得结果，再完成result的初始化。结果尚未取得时，不能提前读取result。

普通函数定义放在main的花括号外；调用可以写在main里面，不表示另一个普通函数的定义也能放进去。本节定义放在main前，让编译器在遇到调用时已经见过接口。源文件中定义写在前，不表示运行先执行它：程序仍从main开始；只有执行到调用，才进入对应函数体。函数的结束与main的结束也不是同一件事。

在这个返回int的函数内，return value + 1;先计算表达式，再把整数结果交回调用处，结束这一次函数调用。它不输出到终端；输出仍需要原来的std::cout语句。调用处拿到结果后，继续完成尚未完成的那条语句，再进入下一条语句。

沿着一次调用走完整条路线

#include <iostream>

int next(int value) {
    return value + 1;
}

int main() {
    int result{next(4)};
    std::cout << result << '\n';
    return 0;
}

1. 运行进入main，遇到result的初始化，需要先得到next(4)的值。
2. 进入next，本次参数value得到4；计算value + 1得5。
3. return把5交回，result的初始化完成，result为5。
4. main继续到输出语句，显示5和换行。main的return 0才是本次程序的成功退出状态。

先读本节新增的四个编译选项

保存、编译、运行的流程沿用新01；从本节开始，命令增加四个用于编译诊断（diagnostics）的选项。诊断是编译器给出的检查信息：warning表示警告，单有警告不一定阻止生成程序；error表示错误，本次构建不能成功。先知道工具怎样处理这些信息，再判断一次编译的结果。

因此，下面命令遇到编译警告也会拒绝本次构建，已学的shell &&就不会启动右边的程序。目录里可能仍有上次生成的程序，不能手动运行它来证明新源码通过。反过来，没有警告也不能证明计算结果正确，还要核对实际输出。四个选项是工具接口，不改变C++语句本身的执行规则；具体诊断集合随工具版本变化，可查Clang官方诊断选项说明。

在下载文件所在目录使用这组新增选项：clang++ -std=c++20 -Wall -Wextra -Wpedantic -Werror definition.cpp -o definition && ./definition。输出应为5。只把调用里的4改成0，重新编译，结果应为1；没有必要改函数定义。

若一个函数接收两个输入，形参之间用逗号分隔，例如接口中的int value, int amount；调用中的shifted(4, 3)也用逗号分隔实参。位置负责对应：4交给第一个形参，3交给第二个。这里的逗号是参数列表的分隔符，不是要求两个输入的求值都从左到右发生。本章多个实参只用没有修改动作的小数值；需要按顺序做的动作先分别写成完整语句。04.5会给出这个双参数函数的完整程序。

小练习：5去了哪里

不运行程序，指出definition.cpp中哪一行进入next、哪一行把5交回、哪一行才真正输出。只把main里接收结果的名字result全部改为answer，会改变next里的参数名或输出吗？

04.2 按值参数 · 预估90分钟

函数里加一，究竟改了谁

上一节用字面量4作为输入。现在输入来自main中的对象x：函数能读取这个值，但函数体里的赋值是否会改到x？要回答这个问题，必须为这次调用和调用者分别记状态，不能仅凭“都从4开始”就把它们画成同一个对象。

参数写作int value时，本章使用的是按值传参（pass by value）：每次调用都有自己的整数参数对象，用实参当时的值初始化它。next(x)读取x，把这个整数值交给本次value。对这个参数做value += 1;只改本次value；不会经由这个int参数自动写回x。这条结论限定于本章的整数副本，不是说任何函数都不能产生外部影响，例如函数仍然可以输出文字。

return value;读取参数里的整数值，把结果交回；返回结果不会自动改写调用者的源对象。调用者可以用结果初始化另一个对象，也可以通过已学赋值明确更新x。给参数初值、在函数里更新、交回结果、调用者保存结果，是四个不同动作。

调用也可以独立写成一条语句：next(x);。函数仍执行，仍产生返回结果；这条语句没有要求保存这个结果，结果便被丢弃。它不是取消调用，也不是把返回值自动写回x。本章普通函数没有要求必须使用返回值的额外属性，不引入新的转换写法来丢弃结果。

完整例一：同一个调用，三种接收方式

#include <iostream>

int next(int value) {
    value += 1;
    return value;
}

int main() {
    int x{4};
    int y{next(x)};
    std::cout << x << ' ' << y << '\n';
    next(x);
    std::cout << x << ' ' << y << '\n';
    x = next(x);
    std::cout << x << ' ' << y << '\n';
    return 0;
}

每一行调用都是新的一次工作，不会沿用上一次value里的5。第三行x变成5的直接原因是main写了赋值；y仍是最初保存的独立整数，没有自动跟随关系。

阶梯第一步：先写预测，再只改输入

盖住状态表，用原输入x=4写出三行输出，并给每次调用的参数单独画格子。然后只把main的x初值改为0，先预测再运行；不要同时改函数体。

04.3 返回路径与void · 预估60分钟

函数从另一条路离开，调用者还会继续吗

一个计算可能在分支里就知道答案，不必再执行余下语句。另一些函数只负责显示一条消息，不需要交回整数。我们要把这两类接口分开，并检查函数有没有遗漏一条正常到达末尾的路径。

普通函数中的**提前返回（early return）**结束当前调用，回到调用者继续。它与新03的main提前退出共享return的跳转形式，但目标不同：magnitude返回3，不表示整个程序以3退出；main还会执行自己的后续语句。

下面的magnitude只接收−100到100：负数取负，零和正数原样返回。本章不把这个受限例子推广到所有int值；新02已讲过整数结果必须可表示。

#include <iostream>

int magnitude(int value) {
    if (value < 0) {
        return -value;
    }
    return value;
}

int main() {
    int result{magnitude(-3)};
    std::cout << result << '\n';
    std::cout << "done" << '\n';
    return 0;
}

输入−3使条件为真，return交回3，函数里后面的return value;不执行。main取得3后输出它，仍然输出done，最后以0结束程序。输入改为0或3会跳过负数分支，走末尾return，输出分别为0、done或3、done。

对本章普通的非void函数，不能让一条执行路径正常走到函数体末尾而没有交回结果。看下面故意缺少返回的版本：

#include <iostream>

int magnitude(int value) {
    if (value < 0) {
        return -value;
    }
}

int main() {
    std::cout << magnitude(3) << '\n';
    return 0;
}

输入3时条件为假，执行会到右花括号，却没有提供所需int结果。这样的普通非void函数若实际走到末尾，行为未定义，不存在可以保证的输出。本章的Clang严格编译会用返回路径警告加-Werror拒绝它，我们只检查编译诊断，不运行坏路径。语言错误不等于任何编译器、任何选项都保证拒绝。 main有已学过的末尾等效return 0特例，不能把这个特例借给其他int函数。

没有要交回的值，也是一种明确接口

返回类型写作void，表示这次调用不提供可供保存的结果值。return;没有后面的表达式，可以提前结束这个void调用；正常走到void函数末尾也会回到调用者。return;不是“返回整数0”，不能把void调用保存成一个int。

#include <iostream>

void show_if_positive(int value) {
    if (value <= 0) {
        return;
    }
    std::cout << value << '\n';
}

int main() {
    show_if_positive(0);
    show_if_positive(3);
    std::cout << "done" << '\n';
    return 0;
}

第一次输入0，执行return;，跳过函数内输出，main接着发起第二次调用。输入3时条件假，输出3，走到void函数末尾返回；main随后输出done。完整输出为3、done。注意：函数没有返回值，却仍有输出这个可观察效果。

小练习：返回值不是退出码，void也不是零

在returns.cpp中，函数交回3后main为什么还能输出done？在void.cpp中，只把第一次实参0改为−2或2，各输出什么？说明“忽略一个int结果”与“调用没有结果的void函数”哪里不同。

04.4 局部作用域与调用过程 · 预估90分钟

同一个名字出现三次，怎样找到正在操作的对象

main有result，另一个函数也有result；函数内部还可能有嵌套块。仅靠名字做一张总表会把几个不同对象合并。我们先区分名字能在哪里用，再给每次活动调用保留独立的一页记录。

新03已教块内名字不能拿到块外使用。调用者的局部名字也不会因为发起调用就进入被调函数的作用域：next不能直接用main的局部名字x来访问那个对象，参数提供的是明确的输入接口。本节补充遮蔽（shadowing）：更内层的块可以声明与外层相同的局部名字；从这个声明开始，在内层使用该名字会找到内层对象。外层对象没有因此被赋新值或消失，离开内层块后名字又对应外层对象。不要在函数体的最外层块再次声明与参数相同的名字；下例使用的是if引入的更内层块。

#include <iostream>

int adjusted(int value) {
    int result{value};
    if (value > 0) {
        int value{9};
        result += value;
        std::cout << value << '\n';
    }
    std::cout << value << '\n';
    return result;
}

int main() {
    int x{4};
    int result{adjusted(x)};
    std::cout << x << ' ' << result << '\n';
    return 0;
}

输入x=4时，adjusted的value为4，result也为4。进入if后声明另一个value，初值9；result += value;中的result在外层，value在内层，所以result变13。块内输出9。离开块后输出外层value的4，再交回result的13。main最后输出4 13，因此三行是9、4、4 13。这份教学例子故意使用同名变量让你辨认；自己的程序通常应选择更容易区分的名字。

一个函数还可以调用另一个函数

函数调用期间，调用者会等待被调用函数给出结果，再继续完成原语句。调用链（call chain）记录这种正在等待的关系；我们用调用栈（call stack）的逻辑图逐层表示当前工作。图只表达控制和各次调用的值，不保证编译器一定在内存中创建同形状的栈框，也不规定每个参数在某条机器指令时销毁。

#include <iostream>

int next(int value) {
    return value + 1;
}

int twice_next(int value) {
    int first{next(value)};
    int second{next(first)};
    return second;
}

int main() {
    int result{twice_next(4)};
    std::cout << result << '\n';
    int again{twice_next(0)};
    std::cout << again << '\n';
    return 0;
}

第一次main调用twice_next(4)：它的value是4；调用next(value)得到5，保存到first；再调用next(first)得到6，保存到second；最后把6交回main。每次next都有自己的参数，本次next读4，下次next读5，没有共享一个会累积的参数对象。

第二次main调用twice_next(0)，重新从value=0开始，first得1、second得2，main输出2。因此完整输出是6、2。没有使用递归；两条next调用写成两条完整语句，明确先完成first再计算second。

小练习：名字和调用分别记账

shadow.cpp只把main的x改为0，会建立内层value吗，最终哪两行会输出？nested-calls.cpp只把第一个twice_next的实参4改为1，后一次输入0的调用会被前一次影响吗？

04.5 声明、默认参数与普通重载 · 预估90分钟

调用处需要知道多少，才能把实参交对

前面总把完整函数体写在main上方。如果想把实现放后面，调用处仍需要事先知道接口。我们还会遇到两种方便写法：省略一个常用输入，以及让同名函数接收不同类型。它们都要先有明确规则，不能凭名字相同就猜调用哪一个。

**函数声明（function declaration）**可以只说明返回类型、名字和参数类型，以分号结束，不提供函数体。例如int next(int value);让后面的调用知道next接收int、返回int。定义包含实际函数体，也声明了函数；它负责提供具体工作。声明本身不会执行一次函数调用，也不会给main创建名为value的对象。

#include <iostream>

int next(int value);

int main() {
    std::cout << next(4) << '\n';
    return 0;
}

int next(int value) {
    return value + 1;
}

这里main前先给声明，main后再给匹配的定义，运行仍输出5。声明让调用可以接受类型检查，但完整程序仍需要对应定义；把声明当作实现并不能让函数凭空产生结果。当前文件内先把两者区分清楚，多文件编译和链接会在新17成为正式练习。

少写一个实参，必须知道由什么补上

在参数后写= 1可以规定默认实参（default argument）。它表示调用处省略该位置时，使用指定的输入；不是每次进入函数都把明确传入的值强行改成1。调用从右侧省略：下面可以省略amount，不能省略value却只交amount。本节只有两个普通参数，默认值是一个小整数字面量。

#include <iostream>

int shifted(int value, int amount = 1) {
    return value + amount;
}

int main() {
    std::cout << shifted(4) << '\n';
    std::cout << shifted(4, 3) << '\n';
    return 0;
}

shifted(4)使用amount=1，返回5；shifted(4, 3)明确提供amount=3，返回7。只把定义中的默认1改为2，第一行变6、第二行仍7。只把第二次调用改为shifted(4, 0)，在原默认1的版本里两行是5、4。

默认实参必须在调用处可见的声明中给出；本例定义在main前，所以符合要求。如果之后把声明和定义分开，只在选定的声明处给同一个默认值，不在相同作用域的定义里重复指定。这里说的是本章普通函数接口，尚未用模板或成员函数的额外规则。

同一个名字，按实参类型选择

**普通函数重载（function overloading）**允许同一名字有不同的参数列表。调用处先根据可见候选及实参类型选择函数，再执行所选函数体。本节仅比较一个int参数与一个double参数，实参也恰好是int或double；无需靠最终输出去猜编译时选了谁。

#include <iostream>

int half(int value) {
    return value / 2;
}

double half(double value) {
    return value / 2.0;
}

int main() {
    std::cout << half(5) << '\n';
    std::cout << half(5.0) << '\n';
    return 0;
}

整数字面量5类型是int，所以half(5)匹配int版本，整数除法结果为2。5.0类型是double，匹配double版本，结果2.5。转换和整数除法来自新02；这里的新规则是根据实参类型选择不同函数体。若把整数实参改为6，只有第一行变3；把double实参改为6.0，只有第二行变3。

不能仅凭返回类型区分两个普通函数：下面两个half的参数列表都是单个int，第二个声明为返回double，不能把它变成另一份合法重载。

#include <iostream>

int half(int value) {
    return value / 2;
}

double half(int value) {
    return value / 2.0;
}

int main() {
    std::cout << half(5) << '\n';
    return 0;
}

这份文件预期编译拒绝。main接收结果用什么类型也不能修复这两个冲突的定义；应当让接口有合理区别，或只保留符合需求的一份函数。本章不做混杂许多隐式转换的候选选择题，所用重载只需上面的精确类型匹配。

小练习：三个看似相近的接口动作

说明声明、默认实参、重载各解决什么问题。defaults.cpp中把默认1改为2后，为什么显式传3的结果不变？为什么不能用double接收变量来修复return-overload-error.cpp？

04.6 函数合同与小检查 · 预估60分钟

结果为零时，怎样知道它是答案而不是失败

现在可以把上一章的循环装进函数，但调用者还需要知道哪些输入可接受、结果代表什么，以及失败时怎么识别。函数名和int返回类型都不能独自说明这些约定。我们把这些约定写在计算之前，再用已学if检查它们。

**函数合同（function contract）在这里指清楚写下的输入范围、成功结果和失败表示，不是某个额外C++关键字。对sum_before，我们约定：0≤n≤100时返回0到n减1的总和；范围外返回−1。合法输入的结果最小为0，最大为0+1+…+99=4950，因此−1不会与合法答案混淆。这个失败码（error code）**是函数自己的约定，与main的进程退出状态另算。

完整例二：让调用者检查一个有边界的函数

#include <iostream>

int sum_before(int n) {
    if (n < 0 || n > 100) {
        return -1;
    }
    int total{0};
    for (int i{0}; i < n; ++i) {
        total += i;
    }
    return total;
}

int main() {
    int n{4};
    int result{sum_before(n)};
    if (result < 0) {
        std::cout << "invalid" << '\n';
        return 1;
    }
    if (sum_before(0) != 0 || sum_before(1) != 0) {
        std::cout << "check failed" << '\n';
        return 1;
    }
    std::cout << result << '\n';
    return 0;
}

输入4时先通过范围检查，total从0开始，普通for处理0、1、2、3，依次累计0、1、3、6，return交回6。main的result为6，不走invalid分支；随后用两次调用检查sum_before(0)和sum_before(1)都为0，最后输出6并退出0。

这两条小检查用的是新03的比较和短路：发现任意一个结果不符，就输出check failed并让main退出1。检查不是因为函数名看起来正确就通过，而是比较真实调用结果。没有使用尚未教过的断言宏、异常或容器。

只把main的n改为0、1或100，输出分别0、0、4950，程序退出0。改为−1或101，sum_before先返回−1，不进入循环；main识别负值，输出invalid并退出1。函数返回−1没有直接结束整个程序，是main读到失败码后选择return 1。

阶梯第二步：把已理解的循环提取成函数

关掉完整例，从新03已懂的累计过程出发，在新文件中定义sum_before，接收一个int n并返回int。先限定调用只提供0到100，再自己写清总数在哪里初始化、循环结束后怎样交回。main分别检查0、1和4，结果应为0、0、6。完成后再按上面合同补范围拒绝。

阶梯第三步：每条路径都有返回，还可能早得不对

下面能编译，每一条结束路径也都交回整数。输入4，合同仍要求总和6；先预测实际结果，再找出导致差异的那一条return。

#include <iostream>

int sum_before(int n) {
    int total{0};
    for (int i{0}; i < n; ++i) {
        total += i;
        return total;
    }
    return total;
}

int main() {
    int result{sum_before(4)};
    std::cout << result << '\n';
    return 0;
}

阶梯第四步：从空文件独立迁移

定义count_even_before：0≤n≤100时统计0到n减1中的偶数，范围外返回−1。main至少发起两次调用，每次都说明本次局部count如何初始化。建议依次用0、1、5，再重复一次5；四个结果应为0、1、3、3。不要把上一章main整段原封不动复制四遍。

#include <iostream>

int count_even_before(int n) {
    if (n < 0 || n > 100) {
        return -1;
    }
    int count{0};
    for (int i{0}; i < n; ++i) {
        if (i % 2 == 0) {
            count += 1;
        }
    }
    return count;
}

int main() {
    int first{count_even_before(0)};
    int second{count_even_before(1)};
    int third{count_even_before(5)};
    int again{count_even_before(5)};
    std::cout << first << '\n';
    std::cout << second << '\n';
    std::cout << third << '\n';
    std::cout << again << '\n';
    return 0;
}

学完后，回答章首的问题：调用表达式提供一次入口，参数给这次计算独立输入，return交回结果；调用者继续执行，并负责决定怎样保存或检查结果。接下来到页面末尾关掉参考做复述，留下自己的源码、预测和实际输出。