What is the difference between function declaration and function definition?

Answer 1

// function declaration

void functionName (int, double);

// function definition

void functionName (int x, double y) {

// implementation...

}

A function declaration informs the compiler of the function's type, its name and the number and type of its arguments. A declaration is required so the compiler knows what the name represents and how it may be used, but it is not necessary to know what it does or how it does what it does.

A definition is also a declaration, but also includes the names of its formal arguments and provides the implementation details of the function itself. A declaration without a definition is not required, however declarations do help programmers to see the interface without being distracted by the implementation details. By placing declarations in a header file, multiple translation units can make use of the same declaration regardless of which translation unit defines the implementation. This also makes it possible to create functions that depend on each other because it would be impossible to define a function that used another function that hadn't yet been declared.

Answer 2

Declaring a variable instantiates the variable but does not initialise it with a value, whereas defining a variable initialises it with a known value.

Whenever we instantiate a variable, memory is set aside for it and we can refer to that memory using the variable's name. However, the memory is left in an uninitialised state -- whatever state that memory had at the time the variable was instantiated will remain the same. We say the value is undefined because if we attempt to use whatever value happens to reside there our program will exhibit undefined behaviour. Once we define a variable, we can safely use it because its value will then be initialised.

Although we should always define a variable before we use it, it can sometimes be beneficial to instantiate the variable first and perform the initialisation later, so long as we do not use the variable before that initialisation occurs. For instance, if we want to copy an array from one location in memory to another, we first need to instantiate the memory to hold the copy, but it is not necessary to initialise that memory because we're about to overwrite that memory with values from the original array. Thus we declare the array first and then the copy operation performs the initialisation, thus defining the copy. Once that is done we can safely use the copy.

It should be noted that whenever we declare an instance of a class (an object) that has one or more constructors, whichever constructor is invoked will initialise the object's data members. Thus an object of this type can always be said to be defined at the point of instantiation. This is of particular importance where the object has a natural default value. For instance, a string object will default to an empty string, thus the string's default constructor will initialise the memory accordingly. For programmers who are used to using two-stage initialisations (declare first, define later), it can come as a surprise to learn that they are in fact initialising their objects twice -- which is far from efficient. Therefore whenever you declare an object, always initialise at the point of declaration unless the default initialisation (if one is provided) is exactly what you want.

Answer 3

When you declare a variable, you simply tell the computer to make a space in the memory for that data object. You don't necessarily have to store a value into the object to declare it. public int NUMBER; Defining a variable means assigning an actual value to that variable. NUMBER = 7;

Answer 4

All definitions are declarations, however not all declarations are definitions.

Consider the following:

int x; // a declaration

int y = 42; // a declaration with definition

The same principle applies to functions:

int foo (int); // a declaration

int bar (int x) { /* ... */ } // a declaration with definition

A declaration with a definition is simply known as a definition because (as mentioned at the start) all definitions are declarations. When we use the term declaration we are usually referring to a declaration that is not (yet) defined.

Declarations introduce a new user-defined name to the compiler. In order to determine which operations are valid for that name and how it may be used, the compiler needs to know the name's type. A function's type is determined by its return type which, unlike named variables, may be declared void to indicate no return type is expected.

In addition, a function declaration must include the number and type of its arguments. The arguments do not require formal names unless the declaration is also a definition and those names are actually used by the function definition. However, naming the formal arguments in a declaration allows us to give a hint to the reader as to the argument's purpose:

int foo (int prime_number); // a declaration with a named argument

The names of formal arguments in a declaration are ignored by the compiler unless the declaration is also a definition and the names are used. However, the definition of a declared function need not use the same formal argument names:

int foo (int prime_number); // declaration

int foo (int n) { /*...*/ } // definition

The main difference is that a definition always has a function body.

We often call declarations interfaces and call definitions implementations because they implement the interface. Generally speaking, an interface should provide all the information required by the reader. There's rarely a need to inspect the implementation details and, in some cases, the implementation details may be "hidden" within a binary executable and won't be accessible to the reader without reverse-engineering the executable.

In a single-pass compiler, the declaration of a function must come before any usage of that function. We call this a forward-declaration. Where a function is used by more than one translation unit, each unit must declare the function. To ensure consistency across all declarations of the same function, we typically place the declaration in a header file (*.h file) and include that header wherever we require the declaration. Note that a declaration does not consume any memory so we can include the same declaration as often as required. Typically we place related function declarations in the same header.

The translation unit that defines a function must include the header that contains its declaration to ensure consistency. However, if the function is local to the translation unit, then we don't need to place the declaration in a header (because no other translation unit requires it), we can simply define the function in the one and only translation unit that uses it.

Answer 5

None, these two phrases mean the same thing.

Function prototyping or function declarationcontains:

name, number and types of parameters, return type and some other details are possible, but no function body is allowed.

Function definition is function definition (prototype) and the body.

Answer 6

Declaration is the act of stating the type of an identifier or object. Definition is the act of creating an instance of that identifier or object. Often, these two acts are performed together, such as...

int a;

...which declares a as an numeric variable of type int, and defines it, giving it an address.

An example of split declaration/definition is a forward definition of a function...

int foo (int, float);

{ some other code }

int foo (int re, float bar) {

{ code for foo }

... the first line declares foo as a function of type int, which accepts two arguments, one an int and one a float. The second line defines foo, associates the arguments with formal parameters re and bar, and provides the code for foo.

Answer 7

Function declaration means to just tell the compiler that this is a user-defined function. While function definition contains the whole body of the function, i.e. its working.

Example:

// This is function declaration

void myfunction();

// This is function definition

void myfunction()

{

printf("This is a user defined function call !");

}

-Manu-

Answer 8

A function declaration declares a function's interface but does not implement it. A function definition is itself a declaration, but it also provides the implementation for that interface. Typically we keep interfaces separate from implementation details because it should only be necessary to know what a function does, not how it does it.

Answer 9

Generally, it means to create a new variable, and possibly give it a value.

Answer 10

function prototype is declared above the main() function.

function definition:a self contained block of statements that are used to perform specific task in C.