函数原型和函数

他之所以不编译这个程序是因为编译器会按顺序读取文件。当编译器为函数的调用（）对main()线6，不知道什么补充的是，因为我们还没有定义（）到10号线！产生第一个错误（“未找到的标识符”）。

tā他 zhī之 suǒ所 yǐ以 bù不 biān编 yì译 zhè这 ge个 chéng程 xù序 shì是 yīn因 wèi为 biān编 yì译 qì器 huì会 àn按 shùn顺 xù序 dú读 qǔ取 wén文 jiàn件 。 dāng当 biān编 yì译 qì器 wéi为 hán函 shù数 de的 diào调 yòng用 （ ） duì对 m a i n ( ) xiàn线 6 ， bù不 zhī知 dao道 shén什 me么 bǔ补 chōng充 de的 shì是 ， yīn因 wèi为 wǒ我 men们 hái还 méi没 yǒu有 dìng定 yì义 （ ） dào到 1 0 hào号 xiàn线 ！ chǎn产 shēng生 dì第 yī一 gè个 cuò错 wù误 （ “ wèi未 zhǎo找 dào到 de的 biāo标 shí识 fú符 ” ） 。

When Visual Studio 2005 gets to the actual declaration of add() on line 10, it also complains about add being redefined. This is somewhat misleading, given that it wasn’t ever defined in the first place. Later versions of Visual Studio correctly omit this additional error message.

当Visual Studio 2005到10线（）实际的宣言，也抱怨将被重新定义。这是有点误导，因为它没有被定义在第一个地方。后来版本的视觉工作室正确省略此附加错误信息。

dāng当 V i s u a l S t u d i o 2 0 0 5 dào到 1 0 xiàn线 （ ） shí实 jì际 de的 xuān宣 yán言 ， yě也 bào抱 yuàn怨 jiāng将 bèi被 chóng重 xīn新 dìng定 yì义 。 zhè这 shì是 yǒu有 diǎn点 wù误 dǎo导 ， yīn因 wèi为 tā它 méi没 yǒu有 bèi被 dìng定 yì义 zài在 dì第 yī一 gè个 dì地 fāng方 。 hòu后 lái来 bǎn版 běn本 de的 shì视 jué觉 gōng工 zuò作 shì室 zhèng正 què确 shěng省 lvè略 cǐ此 fù附 jiā加 cuò错 wù误 xìn信 xī息 。

Despite the redundancy of the second error, it’s useful to note that it is fairly common for a single error to produce (often redundant) multiple compiler errors or warnings.

尽管二次错误的冗余，它是有用的注意，它是相当常见的一个单一的错误，产生（通常是多余的）多个编译器错误或警告。

jǐn尽 guǎn管 èr二 cì次 cuò错 wù误 de的 rǒng冗 yú余 ， tā它 shì是 yǒu有 yòng用 de的 zhù注 yì意 ， tā它 shì是 xiāng相 dāng当 cháng常 jiàn见 de的 yī一 gè个 dān单 yī一 de的 cuò错 wù误 ， chǎn产 shēng生 （ tōng通 cháng常 shì是 duō多 yú余 de的 ） duō多 gè个 biān编 yì译 qì器 cuò错 wù误 huò或 jǐng警 gào告 。

Rule: When addressing compile errors in your programs, always resolve the first error produced first.

规则：在处理程序中编译错误时，始终先解决第一个错误。

guī规 zé则 ： zài在 chǔ处 lǐ理 chéng程 xù序 zhōng中 biān编 yì译 cuò错 wù误 shí时 ， shǐ始 zhōng终 xiān先 jiě解 jué决 dì第 yī一 gè个 cuò错 wù误 。

To fix this problem, we need to address the fact that the compiler doesn’t know what add is. There are two common ways to address the issue.

要解决这个问题，我们需要解决编译器不知道该添加的是什么。解决这个问题有一个共同的方法。

yào要 jiě解 jué决 zhè这 ge个 wèn问 tí题 ， wǒ我 men们 xū需 yào要 jiě解 jué决 biān编 yì译 qì器 bù不 zhī知 dao道 gāi该 tiān添 jiā加 de的 shì是 shén什 me么 。 jiě解 jué决 zhè这 ge个 wèn问 tí题 yǒu有 yī一 gè个 gòng共 tóng同 de的 fāng方 fǎ法 。

Option 1: Reorder the function calls so add() is defined before main():

选项1：排序函数调用，所以（）定义在main()：

#include <iostream>
 
int add(int x, int y)
{
    return x + y;
}
 
int main()
{
    using namespace std;
    cout << "The sum of 3 and 4 is: " << add(3, 4) << endl;
    return 0;
}

这样，通过时间main()（）调用，编译器会知道什么是（）。因为这是这样一个简单的程序，这种变化比较容易。然而，在一个更大的程序，它可以是乏味的，试图找出哪些函数调用的其他功能（以及在什么顺序），使它们可以被声明为顺序。

zhè这 yàng样 ， tōng通 guò过 shí时 jiān间 m a i n ( ) （ ） diào调 yòng用 ， biān编 yì译 qì器 huì会 zhī知 dao道 shén什 me么 shì是 （ ） 。 yīn因 wèi为 zhè这 shì是 zhè这 yàng样 yī一 gè个 jiǎn简 dān单 de的 chéng程 xù序 ， zhè这 zhǒng种 biàn变 huà化 bǐ比 jiào较 róng容 yì易 。 rán然 ér而 ， zài在 yī一 gè个 gèng更 dà大 de的 chéng程 xù序 ， tā它 kě可 yǐ以 shì是 fá乏 wèi味 de的 ， shì试 tú图 zhǎo找 chū出 nǎ哪 xiē些 hán函 shù数 diào调 yòng用 de的 qí其 tā他 gōng功 néng能 （ yǐ以 jí及 zài在 shén什 me么 shùn顺 xù序 ） ， shǐ使 tā它 men们 kě可 yǐ以 bèi被 shēng声 míng明 wéi为 shùn顺 xù序 。

Furthermore, this option is not always possible. Let’s say we’re writing a program that has two functions A and B. If function A calls function B, and function B calls function A, then there’s no way to order the functions in a way that they will both be happy. If you define A first, the compiler will complain it doesn’t know what B is. If you define B first, the compiler will complain that it doesn’t know what A is.

此外，这一选择是不可能的。让我们说，我们正在编写一个程序，它具有2个功能，一个和B，如果函数调用函数，和函数调用函数，那么有没有办法，以一种方式，他们将是幸福的方式。如果你定义了第一个，编译器会抱怨它不知道是什么。如果你先定义了一个，编译器会抱怨它不知道是什么。

cǐ此 wài外 ， zhè这 yī一 xuǎn选 zé择 shì是 bù不 kě可 néng能 de的 。 ràng让 wǒ我 men们 shuō说 ， wǒ我 men们 zhèng正 zài在 biān编 xiě写 yī一 gè个 chéng程 xù序 ， tā它 jù具 yǒu有 2 gè个 gōng功 néng能 ， yī一 gè个 hé和 B ， rú如 guǒ果 hán函 shù数 diào调 yòng用 hán函 shù数 ， hé和 hán函 shù数 diào调 yòng用 hán函 shù数 ， nà那 me么 yǒu有 méi没 yǒu有 bàn办 fǎ法 ， yǐ以 yī一 zhǒng种 fāng方 shì式 ， tā他 men们 jiāng将 shì是 xìng幸 fú福 de的 fāng方 shì式 。 rú如 guǒ果 nǐ你 dìng定 yì义 le了 dì第 yī一 gè个 ， biān编 yì译 qì器 huì会 bào抱 yuàn怨 tā它 bù不 zhī知 dao道 shì是 shén什 me么 。 rú如 guǒ果 nǐ你 xiān先 dìng定 yì义 le了 yī一 gè个 ， biān编 yì译 qì器 huì会 bào抱 yuàn怨 tā它 bù不 zhī知 dao道 shì是 shén什 me么 。

Function prototypes and forward declaration of functions

函数原型和函数的前向声明

hán函 shù数 yuán原 xíng型 hé和 hán函 shù数 de的 qián前 xiàng向 shēng声 míng明

Option 2: Use a forward declaration.

选项2：使用前向声明。

xuǎn选 xiàng项 2 ： shǐ使 yòng用 qián前 xiàng向 shēng声 míng明 。

A forward declaration allows us to tell the compiler about the existence of an identifier before actually defining the identifier.

一个向前声明允许我们在实际上定义标识符之前先向编译器说明一个标识符的存在。

yī一 gè个 xiàng向 qián前 shēng声 míng明 yǔn允 xǔ许 wǒ我 men们 zài在 shí实 jì际 shang上 dìng定 yì义 biāo标 shí识 fú符 zhī之 qián前 xiān先 xiàng向 biān编 yì译 qì器 shuō说 míng明 yī一 gè个 biāo标 shí识 fú符 de的 cún存 zài在 。

In the case of functions, this allows us to tell the compiler about the existence of a function before we define the function’s body. This way, when the compiler encounters a call to the function, it’ll understand that we’re making a function call, and can check to ensure we’re calling the function correctly, even if it doesn’t yet know how or where the function is defined.

在功能的情况下，这使我们能够告诉编译器的功能的存在之前，我们定义的功能的身体。当编译器遇到一个函数调用时，它会理解我们正在进行一个函数调用，并且可以检查以确保我们调用该函数，即使它还不知道如何定义该函数。

zài在 gōng功 néng能 de的 qíng情 kuàng况 xià下 ， zhè这 shǐ使 wǒ我 men们 néng能 gòu够 gào告 sù诉 biān编 yì译 qì器 de的 gōng功 néng能 de的 cún存 zài在 zhī之 qián前 ， wǒ我 men们 dìng定 yì义 de的 gōng功 néng能 de的 shēn身 tǐ体 。 dāng当 biān编 yì译 qì器 yù遇 dào到 yī一 gè个 hán函 shù数 tiáo调 yòng用 shí时 ， tā它 huì会 lǐ理 jiě解 wǒ我 men们 zhèng正 zài在 jìn进 xíng行 yī一 gè个 hán函 shù数 diào调 yòng用 ， bìng并 qiě且 kě可 yǐ以 jiǎn检 chá查 yǐ以 què确 bǎo保 wǒ我 men们 diào调 yòng用 gāi该 hán函 shù数 ， jí即 shǐ使 tā它 hái还 bù不 zhī知 dao道 rú如 hé何 dìng定 yì义 gāi该 hán函 shù数 。

To write a forward declaration for a function, we use a declaration statement called a function prototype. The function prototype consists of the function’s return type, name, parameters, but no function body (the part between the curly braces). And because the function prototype is a statement, it ends with a semicolon.

要编写一个函数的前向声明，我们使用声明语句称为函数原型。函数原型包括函数的返回类型、名称、参数，但没有任何函数体（大括号之间的部分）。因为函数原型声明，它以分号结束。

yào要 biān编 xiě写 yī一 gè个 hán函 shù数 de的 qián前 xiàng向 shēng声 míng明 ， wǒ我 men们 shǐ使 yòng用 shēng声 míng明 yǔ语 jù句 chēng称 wéi为 hán函 shù数 yuán原 xíng型 。 hán函 shù数 yuán原 xíng型 bāo包 kuò括 hán函 shù数 de的 fǎn返 huí回 lèi类 xíng型 、 míng名 chēng称 、 cān参 shù数 ， dàn但 méi没 yǒu有 rèn任 hé何 hán函 shù数 tǐ体 （ dà大 kuò括 hào号 zhī之 jiān间 de的 bù部 fen分 ） 。 yīn因 wèi为 hán函 shù数 yuán原 xíng型 shēng声 míng明 ， tā它 yǐ以 fēn分 hào号 jié结 shù束 。

Here’s a function prototype for the add() function:

这是一本（）函数的函数原型：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
#include <iostream>
 
int add(int x, int y); // forward declaration of add() (using a function prototype)
 
int main()
{
    using namespace std;
    cout << "The sum of 3 and 4 is: " << add(3, 4) << endl; // this works because we forward declared add() above
    return 0;
}
 
int add(int x, int y) // even though the body of add() isn't defined until here
{
    return x + y;