A function is a group of statements that together perform a task. Every C++ program has at least one function, which is main(), and all the most trivial programs can define additional functions. You can divide up your code into separate functions. How you divide up your code among different functions is up to you, but logically the division usually is so each function performs a specific task.
A function declaration tells the compiler about a function's name, return type, and parameters. A function definition provides the actual body of the function.
Types of functions :
- Library functions
- User-defined functions
Some categories of library functions are :
- String handling functions
- Mathematical functions
- Memory allocations functions
- i/o functions
Advantages of functions:
- Program development made easy : Work can be divided among project members thus implementation can be completed in parallel.
- Program testing becomes easy : Easy to locate and isolate a faulty function for further investigation.
- Code sharing becomes possible : A function may be used later by many other programs this means that a c programmer can use function written by others, instead of starting over from scratch.
-
Code re-usability increases :
A function can be used to keep away from rewriting the same block of codes which we are going use two or more locations in a program. This is
especially useful if the code involved is long or complicated.
- Increases program readability : It makes possible top down modular programming. In this style of programming, the high level logic of the overall problem is solved first while the details of each lower level functions is addressed later. The length of the source program can be reduced by using functions at appropriate places.
- Function facilitates procedural abstraction : Once a function is written, it serves as a black box. All that a programmer would have to know to invoke a function would be to know its name, and the parameters that it expects.
- Functions facilitate the factoring of code : Every C program consists of one main( ) function typically invoking other functions, each having a well-defined functionality.
The general form of a C++ function definition is as follows:
return_type function_name( parameter list )
{
body of the function;
}
A C++ function definition consists of a function header and a function body. Here are all the parts of a function:
- Return Type : A function may return a value. The return_type is the data type of the value the function returns. Some functions perform the desired operations without returning a value. In this case, the return type is the keyword void.
- Function Name: This is the actual name of the function. The function name and the parameter list together constitute the function signature.
- Parameters: A parameter is like a place holder. When a function is invoked, you pass a value to the parameter. This value is referred to as actual parameter or argument. The parameter list refers to the type, order, and number of the parameters of a function. Parameters are optional; that is, a function may contain no parameters.
- Function Body: The function body contains a collection of statements that define what the function does.
Function Declarations:
A function declaration tells the compiler about a function name and how to call the function. The actual body of the function can be defined separately.A function declaration has the following parts:
return_type function_name( parameter list );Parameter names are not important in function declaration only their type is required, so following is also valid declaration:
int max(int, int);Function declaration is required when you define a function in one source file and you call that function in another file. In such case, you should declare the function at the top of the file calling the function
Calling a Function:
While creating a C++ function, you give a definition of what the function has to do. To use a function, you will have to call or invoke that function.
When a program calls a function, program control is transferred to the called function. A called function performs defined task and when its return statement is executed or when its function-ending closing brace is reached, it returns program control back to the main program.
To call a function, you simply need to pass the required parameters along with function name, and if function returns a value, then you can store returned value.
For example :
Function_Name();
cout<<function();
Function Arguments:
If a function is to use arguments, it must declare variables that accept the values of the arguments. These variables are called the formal parameters of the function.
The formal parameters behave like other local variables inside the function and are created upon entry into the function and destroyed upon exit.
While calling a function, there are two ways that arguments can be passed to a function:
- Call by value : This method copies the actual value of an argument into the formal parameter of the function. In this case, changes made to the parameter inside the function have no effect on the argument.
- Call by pointer : This method copies the address of an argument into the formal parameter. Inside the function, the address is used to access the actual argument used in the call. This means that changes made to the parameter affect the argument.
- Call by reference : This method copies the reference of an argument into the formal parameter. Inside the function, the reference is used to access the actual argument used in the call. This means that changes made to the parameter affect the argument.
Default Values for Parameters:
When you define a function, you can specify a default value for each of the last parameters. This value will be used if the corresponding argument is left blank when calling to the function.
This is done by using the assignment operator and assigning values for the arguments in the function definition. If a value for that parameter is not passed when the function is called, the default given value is used, but if a value is specified, this default value is ignored and the passed value is used instead.
Inline functions :
C++ inline function is powerful concept that is commonly used with classes. If a function is inline, the compiler places a copy of the code of that function at each point where the function is called at compile time.
Any change to an inline function could require all clients of the function to be recompiled because compiler would need to replace all the code once again otherwise it will continue with old functionality.
To inline a function, place the keyword inline before the function name and define the function before any calls are made to the function. The compiler can ignore the inline qualifier in case defined function is more than a line.
A function definition in a class definition is an inline function definition, even without the use of the inline specifier.
Syntax :
inline function_name()
{
Body of function ;
}
Function overloading :
Function overloading means two or more functions can have the same name but either the number of arguments or the data type of arguments has to be
different. Return type has no role because function will return a value when it is called and at compile time compiler will not be able to determine which
function to call.
For example :
int Add(int X, int Y)
{
return(X+Y);
}
double Add(double m, double n)
{
return(m+n);
}
Copyright © 2014 . All Rights Reserved.
No comments:
Post a Comment