why does a C++ need a forward declaration either through a header or a statement and Java doesn't need? [closed]

Answer 1

Because c++ doesn't have the concept of export modules definitions. If you want to expose a function or a class so other .cpp (modules) can access to it you have to forward declare them in a .h file. Why not write the entire functions (definition) and classes inside the .h instead of forward declare them and write down in a .cpp file? Because when you do #include it pretty much includes the content of the entire .h file in the .cpp so if you include it in all the .cpp files you have, it will be compiled repetitively in each .cpp. which could be extremely inefficient. So you only want forward declaration in a .h and all the definitions in a .cpp.

Answer 2

Java uses .class file format. Compiler gathers information about class and puts it into .class file. In a result linking can be done without involving source files. Note that in Java you have one public class per file requirement, so that for each source .java file one .class is generated.

In C++ code is usually compiled to object files, which have no idea about high level concepts such as classes or structures. Therefore information has to be provided in header files, so that compiler can perform checks (or even to know how to generate some code), before going to link phase.

I was looking for rationale behind forward declarations, but ANSI C by K&R (it's probably a "feature" inherited from C), just states that every variable must be declared before use and that ANSI C made forward declarations of functions consistent with definitions (they were not required to be compatible earlier).

Answer 3

Object files

Java compilers rely on extra information that is compiled into the bytecode (.class) files they produce and which your code uses, while C++ compilers do not store this kind of information in the compiled object code (.obj) files they produces.

Being an older language, C++ relies on the "C model" of program compilation and linkage. This means that object files contain mostly code and data, with only enough metadata needed for object files to be linked together (either statically or dynamically at runtime). Consequently, the compiler relies on header files included while parsing your source code to know about the external class types, functions, and variables your code refers to.

This also means that clients of your C++ code need both the object files (.obj, .lib, or .dll) and header files for your code in order to use it themselves.

Java, being a more modern language, stores a lot of symbolic metadata into the object (.class) files it produces, which allows the compiler to extract the external class types, methods, and variables your code refers to during later compiles.

This also means that clients of your Java code only need the object files (.class or .jar) for your code in order to use it.

Forward declarations

Java compilers make multiple passes on the source code, which means that you only need to declare/defined a variable or method in one place within your code; forward declarations are not necessary because the compiler works harder to determine type information.

C++, in contrast, is defined so that it can be implemented as a single-pass compiler, which means that the compiler needs to know all of the relevant type information about a class, variable, or method at the point it is used in your source code. This means that you have to provide that type declaration information before the actual object definition in your code. This is why header files are used.