The ways of supporting function has changed and improved in C++ as compared to C.Most of these changes are simple and straightforward.However there are a few changes which require you to adopt a new way of thinking and organizing your program's code.Many of these requirements were driven by object oriented facilities of C++.As we go along you would realise that these facilities were invented to make C++ programs safer and more readable than their C equivalents.Let us know the various issues involved in C++ functions.
Function Prototypes
A function prototype is a declaration that defines both : the arguments passed to the function and the type of value returned by the function. If we were to call a function fool( ) which receives a float and int as arguments and returns a double value its prototype would look like this:
double fool(float,int);
The C++ compiler uses the prototype to ensure that the types of the arguments you pass in a function call are same as those mentioned in the prototype.If there is a mismatch the compiler points out immediately.This is known as strong type checking,something which C lacks.
Without strong type checking,it is easier to pass illegal values to functions.For example,a non-prototyped function would allow you to pass an int to a pointer variable,or a float to a long int.The C++ compiler would immediately report such types of errors.In C++ prototypes do more than making sure that actual arguments (those used in calling function) and formal arguments (those used in called function) match in number,order and type.As we would see later,C++ internally generates names for functions,including the argument type information.This information is used when several functions have same names.
Remember that all functions in C++ must be prototyped.This means that every function must have its argument list declared,and the actual definition of a function must exactly match its prototype in the number,order and types of parameters.
//K & R style
double fool(a,b)
int a; float b;
{
//some code
}
//prototype-like style
double fool(int a,float b)
{
//some code
}
Function Overloading
Another significant addition made to the capabilities of functions in C++ is that of function overloading.With this facility you can have multiple functions with the same name,unlike C,where all the functions in a program must have unique names.
In C every function must have a unique name.This becomes annoying.For example,in C there are several functions that return the absolute value of a numeric argument.Since a unique name is required,there is a separate function for each numeric data type.Thus there are three different functions that return the absolute value of an argument:
int abs(int i);
long labs(long l);
double fabs(double d);
All these functions do the same thing,so it seems unnecessary to have three different function names.C++ overcomes this situation by allowing the programmer to create three different functions with the same name.This is called as Function Overloading.Now we can write the function abs as:
int abs(int ii);
long abs(long ll);
double abs(double dd);
The following program illustrates this:
Click here for the program
How does the C++ compiler know which of the abs( )s should be called when a call is made? It decides from the type of the argument being passed during function call.For example,if an int is being passed the integer version of abs( ) gets called,if a double is being passed then the double version of abs( ) gets called and so on.That's quite logical,you would agree.
What if we make a call like,
ch=abs('A')
We have not declared abs( ) function to handle a char.Hence the C++ compiler would report an error.If we want that this call should result into a call to the int version of abs( ),we must make use of typecasting during the call,as shown below:
ch=abs((int);A');
Default Arguments in Functions
In C if a function is defined to receive 2 arguments,whenever we call this function we have to pass 2 values to this function.If we pass one value then some garbage value is assumed for the last argument.As against this,functions in C++ have an ability to define values for arguments that are not passed when the function call is made.
Let us understand this with an example:
void box(int sr=1,int sc=1,int er=24,int ec=80);
void main( )
{
clrscr( );
box(10,20,22,70); //Passing all 4 arguments
box(10,20,15); //Passing 3 arguments
box(5,10); //Passing 2 arguments
box( ); //Passing no arguments
}
When we call the function box( ) with 4 arguments the box is drawn with the arguments passed.However when we call it with 3 arguments the default value mentioned in the prototype of box( ) is considered for the last argument.Likewise when we call the function with 2 arguments the default values for the last 2 arguments are considered.Finally,when we call it with no arguments, a box is drawn with all the default values mentioned in the prototype. Thus the default arguments are used if the calling function doesn't supply them when the function is called.
Note: If one argument is missing when the function is called, it is assumed to be the last argument.Thus,the missing arguments must be the trailing ones./you can leave out the last 3 arguments,but you cannot leave out the last but one and put in the last one.
Function Overloading
Another significant addition made to the capabilities of functions in C++ is that of function overloading.With this facility you can have multiple functions with the same name,unlike C,where all the functions in a program must have unique names.
In C every function must have a unique name.This becomes annoying.For example,in C there are several functions that return the absolute value of a numeric argument.Since a unique name is required,there is a separate function for each numeric data type.Thus there are three different functions that return the absolute value of an argument:
int abs(int i);
long labs(long l);
double fabs(double d);
All these functions do the same thing,so it seems unnecessary to have three different function names.C++ overcomes this situation by allowing the programmer to create three different functions with the same name.This is called as Function Overloading.Now we can write the function abs as:
int abs(int ii);
long abs(long ll);
double abs(double dd);
The following program illustrates this:
Click here for the program
How does the C++ compiler know which of the abs( )s should be called when a call is made? It decides from the type of the argument being passed during function call.For example,if an int is being passed the integer version of abs( ) gets called,if a double is being passed then the double version of abs( ) gets called and so on.That's quite logical,you would agree.
What if we make a call like,
ch=abs('A')
We have not declared abs( ) function to handle a char.Hence the C++ compiler would report an error.If we want that this call should result into a call to the int version of abs( ),we must make use of typecasting during the call,as shown below:
ch=abs((int);A');
Default Arguments in Functions
In C if a function is defined to receive 2 arguments,whenever we call this function we have to pass 2 values to this function.If we pass one value then some garbage value is assumed for the last argument.As against this,functions in C++ have an ability to define values for arguments that are not passed when the function call is made.
Let us understand this with an example:
void box(int sr=1,int sc=1,int er=24,int ec=80);
void main( )
{
clrscr( );
box(10,20,22,70); //Passing all 4 arguments
box(10,20,15); //Passing 3 arguments
box(5,10); //Passing 2 arguments
box( ); //Passing no arguments
}
When we call the function box( ) with 4 arguments the box is drawn with the arguments passed.However when we call it with 3 arguments the default value mentioned in the prototype of box( ) is considered for the last argument.Likewise when we call the function with 2 arguments the default values for the last 2 arguments are considered.Finally,when we call it with no arguments, a box is drawn with all the default values mentioned in the prototype. Thus the default arguments are used if the calling function doesn't supply them when the function is called.
Note: If one argument is missing when the function is called, it is assumed to be the last argument.Thus,the missing arguments must be the trailing ones./you can leave out the last 3 arguments,but you cannot leave out the last but one and put in the last one.
Default arguments are useful in 2 cases:
a) While making a function call if you don't want to take the trouble of writing arguments which almost always has the same value.
b) They are also useful in such cases where,after having written a program we decide to increase the capabilities of a function by adding another argument.Using default arguments means that the existing function calls can continue to use old number of arguments,while new function calls can use more.
Operator Overloading
Operator Overloading is one of the most fascinating features of C++.It can transform,obscure program listings into intuitive obvious ones.By overloading operators we can give additional meaning to operators like +,*,-,<=,>=,etc. which by default are supposed to work only on standard data types like ints,floats etc. For example if str1 and str2 are two character arrays holding strings "Bombay" and "Nagpur" in them then to store "BombayNagpur" in a third string str3, in C we need to perform the following operations:
char str1[20] = "Nagpur";
char str2[ ] = "Bomaby";
char str3[20];
strcpy(str3,str1);
strcat(str3,str2);
No doubt this does the desired task but don't you think that the following form would have made more sense:
str3 = str1 + str2;
Such a form would obviously not work with C,since we are attempting to apply the + operator on non-standard data types (strings) for which addition operation is not defined. That's the place where C++ scores over C,because it permits the + operator to be overloaded such that it knows how to add two strings.
Click here for a Program on Function Overloading
Inline Functions
One of the important advantages of using functions is that they help us save memory space.As all the calls to the function cause the same code to be executed;the function body need not be duplicated in memory.
Imagine a situation where a small function is getting called several times in a program.As you must be aware,there are certain overheads involved while calling a function.Time has to be spent on passing values,passing control,returning value and returning control.In such situations to save the execution time you may instruct the C++ compiler to put the code in the function body directly inside the code in the calling program.That is, at each place where there is a function call in the source file, the actual code from the function would be inserted, instead of jump to the function. Such functions are called inline functions. The in-line nature of the individual copy of the function eliminates the function-calling overhead of a traditional function.The following program shows inline function at work.
#include<iostream.h>
inline void reporterror(char *str)
{
cout<<endl<<str;
exit(1);
}
void main( )
{
//code to open source file
if (fileopeningfailed)
reporterrer("Unable to open source file");
//code to open target file
if(fileopeningfailed)
reporterror("Unable to open target file");
}
Click here for the Program on Inline Functions
a) While making a function call if you don't want to take the trouble of writing arguments which almost always has the same value.
b) They are also useful in such cases where,after having written a program we decide to increase the capabilities of a function by adding another argument.Using default arguments means that the existing function calls can continue to use old number of arguments,while new function calls can use more.
Operator Overloading
Operator Overloading is one of the most fascinating features of C++.It can transform,obscure program listings into intuitive obvious ones.By overloading operators we can give additional meaning to operators like +,*,-,<=,>=,etc. which by default are supposed to work only on standard data types like ints,floats etc. For example if str1 and str2 are two character arrays holding strings "Bombay" and "Nagpur" in them then to store "BombayNagpur" in a third string str3, in C we need to perform the following operations:
char str1[20] = "Nagpur";
char str2[ ] = "Bomaby";
char str3[20];
strcpy(str3,str1);
strcat(str3,str2);
No doubt this does the desired task but don't you think that the following form would have made more sense:
str3 = str1 + str2;
Such a form would obviously not work with C,since we are attempting to apply the + operator on non-standard data types (strings) for which addition operation is not defined. That's the place where C++ scores over C,because it permits the + operator to be overloaded such that it knows how to add two strings.
Click here for a Program on Function Overloading
Inline Functions
One of the important advantages of using functions is that they help us save memory space.As all the calls to the function cause the same code to be executed;the function body need not be duplicated in memory.
Imagine a situation where a small function is getting called several times in a program.As you must be aware,there are certain overheads involved while calling a function.Time has to be spent on passing values,passing control,returning value and returning control.In such situations to save the execution time you may instruct the C++ compiler to put the code in the function body directly inside the code in the calling program.That is, at each place where there is a function call in the source file, the actual code from the function would be inserted, instead of jump to the function. Such functions are called inline functions. The in-line nature of the individual copy of the function eliminates the function-calling overhead of a traditional function.The following program shows inline function at work.
#include<iostream.h>
inline void reporterror(char *str)
{
cout<<endl<<str;
exit(1);
}
void main( )
{
//code to open source file
if (fileopeningfailed)
reporterrer("Unable to open source file");
//code to open target file
if(fileopeningfailed)
reporterror("Unable to open target file");
}
Click here for the Program on Inline Functions
