C++ 中的前向声明是什么？

Question

在此链接中，提到了以下内容：

add.cpp：

int add(int x, int y)
{
    return x + y;
}

main .cpp：

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

我们使用了前向声明，以便编译器在编译 main.cpp 时知道“add”是什么。如前所述，为您想要使用的位于另一个文件中的每个函数编写前向声明可能会很快变得乏味。

您能进一步解释一下“前向声明”吗？如果我们在main函数中使用它会有什么问题呢？

Answer 1

为什么在 C++ 中需要前向声明

编译器希望确保您没有犯拼写错误或向函数传递了错误数量的参数。因此，它坚持在使用之前首先看到“add”（或任何其他类型、类或函数）的声明。

这实际上只是允许编译器更好地验证代码，并允许它清理零散的内容，以便它可以生成一个外观整洁的目标文件。如果您不必转发声明内容，编译器将生成一个目标文件，该文件必须包含有关函数 add 可能是什么的所有可能猜测的信息。当 add 函数可能位于链接器的不同目标文件中时，链接器必须包含非常聪明的逻辑来尝试确定您实际打算调用哪个 add与使用 add 生成 dll 或 exe 的一个连接。链接器可能会得到错误的add。假设您想使用 int add(int a, float b)，但不小心忘记写它，但链接器发现已经存在 int add(int a, int b) code> 并认为这是正确的，并使用了它。您的代码可以编译，但不会执行您期望的操作。

因此，为了保持明确并避免猜测等，编译器坚持要求您在使用之前声明所有内容。

声明和定义之间的区别

顺便说一句，了解声明和定义之间的区别很重要。声明只是提供足够的代码来显示某些内容，因此对于函数来说，这是返回类型、调用约定、方法名称、参数及其类型。但是，该方法的代码不是必需的。对于定义，您需要声明，然后还需要函数的代码。

前向声明如何显着减少构建时间

您可以通过 #includ 将函数声明放入当前的 .cpp 或 .h 文件中'ing 已包含函数声明的标头。但是，这可能会减慢您的编译速度，特别是如果您将标头#include放入程序的.h而不是.cpp中，如下所示#includes 您正在编写的 .h 的所有内容最终也会 #include' 您为其编写的 #includes 的所有标头。突然间，即使您只想使用一两个函数，编译器也会有 #included 页面和需要编译的代码页面。为了避免这种情况，您可以使用前向声明，只需在文件顶部自行键入函数的声明即可。如果您只使用几个函数，那么与始终 #include 标头相比，这确实可以使您的编译速度更快。对于真正的大型项目，差异可能是一个小时或更长的编译时间，缩短到几分钟。

打破两个定义相互使用的循环引用

此外，前向声明可以帮助您打破循环。这是两个函数都尝试互相使用的地方。发生这种情况时（这是一件完全有效的事情），您可以#include一个头文件，但该头文件尝试#include您的头文件当前正在编写...然后 #includes 另一个标头，其中 #includes 您正在编写的标头。您陷入了先有鸡还是先有蛋的情况，每个头文件都试图重新 #include 另一个头文件。要解决此问题，您可以在其中一个文件中前向声明所需的部分，并将 #include 保留在该文件之外。

例如：

File Car.h

#include "Wheel.h"  // Include Wheel's definition so it can be used in Car.
#include <vector>

class Car
{
    std::vector<Wheel> wheels;
};

File Wheel.h

嗯...此处需要将 Car 声明为 Wheel 有一个指向 Car 的指针，但是 Car.h 不能包含在此处，因为这会导致编译器错误。如果包含 Car.h ，则会尝试包含 Wheel.h ，其中包含 Car.h ，其中包含 Wheel .h 并且这种情况将永远持续下去，因此编译器会引发错误。解决方案是转发声明Car：

class Car;     // forward declaration

class Wheel
{
    Car* car;
};

如果类Wheel有需要调用Car方法的方法，这些方法可以定义在< code>Wheel.cpp 和 Wheel.cpp 现在能够包含 Car.h 而不会导致循环。

Answer 2

编译器查找当前翻译单元中使用的每个符号是否先前在当前单元中声明过。这只是一个风格问题，在源文件的开头提供所有方法签名，而定义则在稍后提供。它的重要用途是当您使用指向一个类的指针作为另一个类的成员变量时。

//foo.h
class bar;    // This is useful
class foo
{
    bar* obj; // Pointer or even a reference.
};

// foo.cpp
#include "bar.h"
#include "foo.h"

因此，尽可能在类中使用前向声明。如果你的程序只有函数（带有ho头文件），那么在开始时提供原型只是一个风格问题。如果头文件存在于一个只有函数的标头的普通程序中，无论如何都会出现这种情况。

Answer 3

因为 C++ 是自上而下解析的，所以编译器需要在使用事物之前了解它们。因此，当您在主函数中引用：时，

int add( int x, int y )

编译器需要知道它存在。为了证明这一点，请尝试将其移至主函数下方，您将收到编译器错误。

因此，“转发声明”就是其包装上的内容。它在使用之前声明一些东西。

通常，您会在头文件中包含前向声明，然后以与包含 iostream 相同的方式包含该头文件。

Answer 4

C++ 中的术语“前向声明”主要仅用于类声明。请参阅（结尾）这个答案 为什么类的“前向声明”实际上只是一个带有奇特名称的简单类声明。

换句话说，“前向”只是向该术语添加了镇流器，因为任何声明都可以被视为前向，因为它在使用之前声明了一些标识符。

（至于什么是声明而不是定义，请再次参见定义和声明之间有什么区别？ ）

Answer 5

当编译器看到 add(3, 4) 时，它需要知道这意味着什么。通过前向声明，您基本上告诉编译器 add 是一个接受两个 int 并返回一个 int 的函数。这对于编译器来说是重要的信息，因为它需要将 4 和 5 以正确的表示形式放入堆栈，并且需要知道 add 返回的内容是什么类型。

那时，编译器并不担心 add 的实际实现，即它在哪里（或者是否有有），并且如果它编译。稍后，在调用链接器时编译源文件之后，就会看到这一点。

Answer 6

int add(int x, int y); // forward declaration using function prototype

你能解释一下“前向声明”吗
更进一步？如果出现什么问题
我们在 main() 函数中使用它吗？

它与#include"add.h"相同。如果您知道，预处理器会在您编写 #include 指令的 .cpp 文件中扩展您在 #include 中提到的文件。这意味着，如果您编写 #include"add.h"，您会得到相同的结果，就像您在执行“前向声明”一样。

我假设 add.h 有这一行：

int add(int x, int y); 

Answer 7

一个关于以下内容的快速附录：通常您将这些前向引用放入属于实现函数/变量等的 .c(pp) 文件的头文件中。在你的例子中它看起来像这样：
add.h：

extern int add(int a, int b);

关键字 extern 表明该函数实际上是在外部文件中声明的（也可以是库等）。
你的 main.c 看起来像这样：

#include 
#include "add.h"

int main()
{
.
.
.

Answer 8

一个问题是，编译器不知道你的函数传递的是哪一种值；假设该函数在这种情况下返回一个 int，但这可能是正确的，也可能是错误的。另一个问题是，编译器不知道您的函数需要哪种类型的参数，并且如果您传递了错误类型的值，则无法警告您。有一些特殊的“提升”规则，在传递浮点值到未声明的函数时适用（编译器必须将它们扩展为 double 类型），这通常不是函数实际期望的，导致很难发现错误在运行时。