Function/Variable Scope   «Prev  Next»
Lesson 12

C++ Functions and Variables Conclusion

In this module you learned the syntax, use, and scope of C++ functions and variables. In particular you learned:
  1. How C++ uses function prototypes
  2. How using default function arguments can save you time
  3. What it means to overload a function
  4. How to use the keyword inline to speed up programs
  5. The difference between file scope and local scope
  6. How the extern and static storage classes are useful in multifile programs
  7. The rules of linkage for multifile programs
  8. What namespaces are and why they are useful

Function Overloading

Function overloading is the process of using the same name for two or more functions.The secret to overloading is that each redefinition of the function must use either different types of parameters or a different number of parameters. It is only through these differences that the compiler knows which function to call in any given situation. For example, this program overloads myfunc( ) by using different types of parameters. 
#include <iostream>
using namespace std;
int myfunc(int i); // these differ in types of parameters
double myfunc(double i);
int main(){
 cout << myfunc(10) << " "; // calls myfunc(int i)
 cout << myfunc(5.4); // calls myfunc(double i)
 return 0;
}
double myfunc(double i){
 return i;
}
int myfunc(int i){
 return i;
}

The next program overloads myfunc( ) using a different number of parameters: 
#include <iostream>
using namespace std;
int myfunc(int i); // these differ in number of parameters
int myfunc(int i, int j);
int main(){
 cout <<myfunc(10) << " "; // calls myfunc(int i)
 cout << myfunc(4, 5); // calls myfunc(int i, int j)
 return 0;
}
int myfunc(int i){
 return i;
}
int myfunc(int i, int j){
 return i*j;
}
As mentioned, the key point about function overloading is that the functions must differ in regard to the types and/or number of parameters. Two functions differing only in their return types cannot be overloaded. For example, this is an invalid attempt to overload myfunc( ): 
int myfunc(int i); // Error: differing return types are
float myfunc(int i); // insufficient when overloading.

Sometimes, two function declarations will appear to differ, when in fact they do not. For example, consider the following declarations. 
void f(int *p);
void f(int p[]); // error, *p is same as p[]

Remember, to the compiler *p is the same as p[ ]. Therefore, although the two prototypes appear to differ in the types of their parameter, in actuality they do not.

Functions Scope - Quiz

Click the Quiz link below to take a multiple-choice quiz covering the topics presented in this module.
Functions Scope - Quiz