Skip over navigation


Functions in C++

Function Overloading and Function Templates


Function Overloading and Function Templates, page 2

page 1 of 2

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:

Follow Us