A function groups a number of program
statements into a unit and gives it a name. This unit can then be
invoked from other parts of the program.
C++ has added many new features to
functions to make them more reliable and flexible. C++ function can
be overloaded to make it perform different tasks depending on the
argument passed to it.
Standard
C and C++ use a feature called function
prototyping.
With function prototyping, you
must use a description of the types of arguments when declaring and
defining a function. This description is the “prototype.” When
the function is called, the compiler uses the prototype to ensure
that the proper arguments are passed in and that the return value is
treated correctly. If the programmer makes a mistake when calling the
function, the compiler catches the mistake.
In
a function prototype, the argument list contains the types of
arguments that must be passed to the function and (optionally for the
declaration) identifiers for the arguments. The order and type of the
arguments must match in the declaration, definition, and function
call. Here’s an example of a function prototype in a declaration:
int
translate(float
x, float
y, float
z);
You do not
use the same form when declaring variables in function prototypes as
you do in ordinary variable definitions. That is, you cannot say:
float x, y, z.
You must indicate the type of each
argument. In a function declaration, the following form is also
acceptable:
int
translate(float,
float,
float);
Since the
compiler doesn’t do anything but check for types when the function
is called, the identifiers are only included for clarity when someone
is reading the code.
In the
function definition, names are required because the arguments are
referenced inside the function:
int
translate(float
x, float
y, float
z)
{
x = y = z;
}
In both C and C++, the declaration
func(void); means an empty argument list. The void
keyword means “nothing” in this case .
Source: C++ Notes
hurrrey..
ReplyDelete