In computer programming, the forward declaration is a declaration identifier (which shows entities like types, variables, constants, or functions) that have not been fully defined by the programmer..
The compiler needs to know the specific properties of the identifier (the size for memory allocation, the type of data for type checking, such as the signature type of the function), but no other details, such as the particular value it has (in the case of variables or constants) or definitions (in case function). This is very useful for single-pass compilers and separate compilations.
Advanced declarations are used in languages ​​that require declarations before use; it is necessary to reconcile each other in such a language, since it is not possible to define such functions (or data structures) without forward reference in one definition: one function (each, the data structure) must be defined first. It's also useful to allow flexible code organization, for example if one wants to place the main body at the top, and call the function underneath.
In other languages ​​forward declarations are not required, which generally require multi-pass compilers and some compilations must be suspended to link time. In this case the identifiers must be defined (variables initialized, function defined) before they are used in the implementation, but need not be defined before they are used in the source code for compilation or interpretation: the identifiers need not be immediately resolved into existing entities.
Video Forward declaration
Example
The basic example in C is:
In C and C, the above line represents the forward declaration of a function and is a function prototype. After processing this declaration, the compiler will allow the program code to refer to the printThisInteger entity in the rest of the program. The definition for a function must be provided somewhere (the same or other files, where it would be the responsibility of the linker to correctly match the reference to a particular function in one or more object files by definition, which must be unique, in another):
Variables may have only forward declarations and lack of definitions. During compile time, this is initialized by the language specific rules (to undefined values, 0, NULL pointers,...). Variables defined in other source/object files must have forward declarations specified with the extern keyword:
In Pascal and other Wirth programming languages, it is a general rule that all entities must be declared before use, and thus forward declarations are necessary for mutual recursion, for example. In C, the same general rule applies, but with the exception of unannounced functions and incomplete types. Thus, in C it is possible (though unwise) to apply a pair of mutually recursive functions thus:
In Pascal, the same implementation requires a forward declaration seconds to precede its use in first . Without a forward declaration, the compiler will generate an error message indicating that the second identifier has been used without being declared.
Maps Forward declaration
Class
In some object-oriented languages ​​like C and Objective-C, it is sometimes necessary to forward the declared class. This is done in situations when it is necessary to know that the class name is a type, but where there is no need to know its structure.
In C, classes and structs can be forwarded-declent like this:
In C, the class can be forwarded if you only need to use the pointer-to-that-class type (since all object pointers are the same size, and this is what the compiler is concerned). This is very useful in class definitions, e.g. if the class contains a member which is a pointer (or reference) to another class.
Forward-declaration is used to avoid unnecessary clutches that help reduce compilation time by reducing the number of header inclusions. It has three advantages:
- subtract the number of files opened by #include (hence the number of operating system calls)
- reduces the volume of previously processed files (because headers are not included)
- reduces the impact of recompilation when the forward declared class is modified.
Using forward declarations to prevent circular references is a bad practice because it often hides architectural issues that need to be resolved using the interface.
The forward class declaration is not enough if you need to use actual class types, for example, if you have members whose type is that class directly (not a pointer), or if you need to use it as a base class, or if you need to use class methods in a method.
In Objective-C, classes and protocols can be forwarded like this:
In Objective-C, classes and protocols can be forwarded forward if you only need to use them as part of the object pointer type, ie. MyClass * or id & lt; MyProtocol & gt; . This is very useful in class definitions, e.g. if the class contains a member which is a pointer to another class; to avoid circular references (ie classes that may also contain members who are pointers to this class), we simply continue-declare the class instead.
A forward declaration of a class or protocol is not enough if you need to subclass that class or implement that protocol.
Referral reference
The term future reference is sometimes used as a synonym for forward declaration . However, it is more often taken to refer to the actual usage of an entity before any statement; that is, the first reference to seconds in the above code is the forward reference. Thus, we can say that because forward declarations are mandatory in Pascal, forward references are prohibited.
Forward reference example (valid) in C:
In this example, there are two references to myValue before being declared. C generally prohibits forward reference, but they are allowed in the special case of class members. Since the accessor member function can not be compiled until the compiler knows the member variable type myValue , it is the author's responsibility to remember the accessor definition. code> until he sees the myValue declaration.
Allowing forward reference can greatly increase the complexity and memory requirements of a compiler, and generally prevent the compiler from being implemented in a single pass.
References
Source of the article : Wikipedia
0 Comments