Difference between prototype declaration and forward declaration?

Question

So I have this code:

class xx
{
    int getnum(); //Is this a forward declaration or a prototype declaration and why?
};

int xx::getnum()
{
    return 1+3;
         


        

Answer 1

Forward declaration is a type of declaration where you specify an Identifier for a Variable, Constant, Type or a Function without giving it's implementation. it actually tells the compiler about an entity with some meta data like name, size etc.

On the other hand, by prototype declaration for a Function means the declaration of a Function with a name and type signature without specifying the function body. So it's only for the function concept, not for variables, constants or types. And so forward declaration can be regarded as a superset of prototype declaration.

For the above example, according to definitions, it's both forward declaration and prototype declaration. Hopefully I am not wrong.

Answer 2

Neither the term "forward declaration" nor "prototype declaration" are defined in the C++ standard, so very strictly speaking, it's neither. It is simply a declaration. If you want to be more specific, you could call it a non-defining declaration, or "a declaration which is not a definition."

When the words "forward declaration" are used in the standard, they are used to refer to declarations which declare, but do not define, the thing (function or class) they declare. Following this usage, int getnum() is therefore a forward declaration.

"Prototype declaration" of a function is used even less in the standard⁽¹⁾, and mostly when talking about [in]compatibility with C. However, when used, it refers to the exact same concept as a forward declaration of that function. Going by this, you could also call int getnum(); a prototype declaration.

To summarise, the terms "forward declaration" and "prototype declaration" have no formal definition, but from the way they are normally used and understood, int getnum(); can be described as either.

---

⁽¹⁾ However, a similar term "function prototype scope" is defined in the standard (C++17 N4659 [basic.scope.proto] 6.3.4/1). It establishes the scope of function parameter names in a non-defining function declaration, and it's the closest enclosing function declarator.

Answer 3

C++ only allows full prototype declarations of functions, unlike C in which something like int getnum(); could be a forward declaration of something like int getnum(int);

C.1.7 Clause 8: declarators [diff.decl]

8.3.5 Change: In C ++ , a function declared with an empty parameter list takes no arguments. In C, an empty parameter list means that the number and type of the function arguments are unknown.

Example:

int f(); // means int f(void) in C ++, int f( unknown ) in C

Rationale: This is to avoid erroneous function calls (i.e., function calls with the wrong number or type of arguments).

Effect on original feature: Change to semantics of well-defined feature. This feature was marked as “obsolescent” in C.

Difficulty of converting: Syntactic transformation. The function declarations using C incomplete declaration style must be completed to become full prototype declarations. A program may need to be updated further if different calls to the same (non-prototype) function have different numbers of arguments or if the type of corresponding arguments differed.

Answer 4

A forward declaration is a declaration of an identifier (denoting an entity such as a type, a variable, a constant, or a function) for which the programmer has not yet given a complete definition.

On the other hand a prototype refers to a function not an identifier.

Hope the following clear things out for you!

int getnum(); // Function prototype. You have not yet implemented the body of getnum() function, thus its a forward delcaration. 
class RandomClass; // Forward declaration of RandomClass. You have not yet implemented this class but you need it for the rest of your code.

class xx{
    RandomClass *foo; // Our need of having a member like that, made us make a forward declaration of the class RandomClass, above class xx
    void BarFunction(); // Function Prototype!
};

int getnum(){ //This is the simply the body of your prototype above. Has nothing to do with the classes
    return 1+3;
}

void BarFUnction(){
     cout << "foo-bar\n" ;
}