 |
Shopping Cart 
Checkout
|
 |
 |
|
|
Home : Math & Science : Computer Science Study Guides : C++ Fundamentals : Functions : Function Overloading and Function Templates
Function Overloading and Function Templates
It will often be convenient to use the same
function
name twice. Suppose, for instance, that you have a function that returns the volume of a box, given
the three sides:
int volume(int x, int y, int z){
return x * y * z;
}
and that you also want to have a similar function compute the same thing, except
for floating point values:
float volume(float x, float y, float z){
return x * y * z;
}
Because C++ allows function overloading, you are allowed to have functions
sharing the same name like this. As long as the return type or the argument
types of the two functions are different, you can have as many different
versions of a function as you need. Keep in mind while programming that you
should always keep it clear which overloaded function you are using.
You can also create a function with the same name and return type, but with a
different number of arguments:
int volume(int x, int y) { // suppose you know that z is always 1
return x * y;
}
This function has the same name and return type, but it has only 2 arguments
instead of 3. A better way to achieve the same effect is to use default
arguments. If you know that z is usually equal to 1, but still want the
freedom to specify it as needed, include a default value for z:
int volume(int x, int y, int z = 1){
return x * y * z;
}
Then you can call the volume function with or without a third argument. You can
have as many default arguments as you want, as long as they are all at the end
of the argument list. In addition you cannot "skip" a default argument when you
call a function. Consider the following definition:
int volume(int x, int y = 2, int z = 1) {
return x * y * z;
}
When you call the volume function, you cannot specify only x and z
(hence skipping over y) because it will look to the compiler like you are
specifying x and y.
An even better way to handle the different volume functions is to create a
function template. It would get awfully repetitive to type out many times
what amounts to the same function for different data types. C++ lets you define
functions that are not specific to a data type. Consider a template to create
functions that will return the lesser of two arguments of any data type:
template <class your_type>
your_type min_num(your_type x, your_type y) {
return (x < y) ? x : y;
}
You can replace "your_type" with almost any name you choose. After defining a
function template, you can then simply call the function with arguments of any
data type, as long as you are consistent:
int lesser_int = min_num(2, 3); float lesser_float = min_num(6.7, 8.9); long lesser_long = min_num(1234567, 474839);
By creating such a template, you are essentially creating as many functions as
there are data types, and in a neat and concise manner. You can also have
multiple unspecified data types within one function:
template <class type1, class type2>
type1 exp(type1 a, type2 b) {
return (b <= 0) ? 1 : a * exp(a, b - 1);
}
By arranging a template in this manner, the programmer can use two arbitrary
data types, called type1 and type2 in the function template definition,
as arguments to exp(). Note the use of recursion.
 |
||||||||||||||||||
Study Guides
|
||||||||||||||||||
Message Boards
|
||||||||||||||||||
SparkCharts
|
||||||||||||||||||
Reference Tools
|
||||||||||||||||||
SparkCollege
|
||||||||||||||||||
|
|
||||||||||||||||
|
||||||||||||||||
|
||||||||||||||||
©2006 SparkNotes LLC, All Rights Reserved.