int add( int a, int b );
int add( int, int );
- A function which takes an int and a float, and returns a double.
- Answer:
double myfunction( int, float );
- Answer:
- A function which takes no arguments and returns no value.
- Answer:
void yourfunction( void );
- Answer:
Operation
Calling a Function
- A function is called by using the function name, followed by a set of parentheses containing the data to be passed to the function.
- The data passed to the function are referred to as the "actual" parameters. The variables within the function which receive the passed data are referred to as the "formal" parameters.
- The formal parameters are local variables, which exist during the execution of the function only, and are only known by the called function. They are initialized when the function starts by copies of the data passed as actual parameters. This mechanism, known as "pass by value", ensures that the called function can not directly change the values of the calling functions variables. ( Exceptions to this will be discussed later. )
- To call a function which takes no arguments, use an empty pair of parentheses.
- Example: total = add( 5, 3 );
- VERY IMPORTANT: It is crucial that the number and types of actual parameters passed match with the number and types of parameters expected by the functions formal parameter list.
- NOTE CAREFULLY: The actual parameters passed by the calling program and the formal parameters used to receive the values in the called function will often have the same variable names. However it is very important to recognize that they are totally different independent variables ( because they exist in different scopes, see below ), whether they happen to have the same name or not.
- Example: In the code below, the variables x, y, z, and x again in main are used to initialize the variables x, z, b, and c in the function. The fact that x and z appear in both main and the function is irrelevant - They are independent variables with independent values.
void func( double x, double z, double b, double c ); int main( void ) { double x( 1.0 ), y( 2.0 ), z( 3.0 ); func( x, y, z, x );- The call to the function above initializes the function parameters equivalently to the following assignment statements:
- x in func = x in main
- z in func = y in main
- b in func = z in main
- c in func = x in main
Returning from a Function
- A function may return a single value by means of the return statement.
- Any variable changes made within a function are local to that function. A calling function's variables are not affected by the actions of a called function. ( When using the normal pass-by-value passing mechanism for non-arrays. See also the section on alternte passing mechanisms below. )
- The calling function may choose to ignore the value returned by the called function. For example, both printf and scanf return values which are usually ignored.
- The value returned by a function may be used in a more complex expression, or it may be assigned to a variable.
- Note carefully that in the sample program shown below, it is the assignment statement which changes the value of y in the main program, not the function.
Sample Program Calling a Function
int add_two( int x ); // Adds 2 to its argument and returns the result
main() { // <----------------------------------------------------------- int main( void )
int y = 5;
cout << "Before calling any function, y = " << y << endl;
add_two( y );
cout << "After calling the function once, y = " << y << endl;
y = add_two( y );
"After calling the function twice, y = " << y << endl;
return 0;
} // main
int add_two( int x ) { // <---------------------------------------- int add_two( int )
cout << "In function, x changed from " << x;
x += 2;
cout << " to " << x << endl;
return x;
} // add_two
Output:
Before calling any function, y = 5
In function, x changed from 5 to 7
After calling the function once, y = 5
In function, x changed from 5 to 7
After calling the function twice, y = 7
Data Passing Mechanisms
Pass By Value
- Ordinary data types ( ints, floats, doubles, chars, etc ) are passed by value in C/C++, which means that only the numerical value is passed to the function, and used to initialize the values of the functions formal parameters.
- Under the pass-by-value mechanism, the parameter variables within a function receive a copy of the variables ( data ) passed to them.
- Any changes made to the variables within a function are local to that function only, and do not affect the variables in main ( or whatever other function called the current function. ) This is true whether the variables have the same name in both functions or whether the names are different.
Pass by Reference
- C++ introduced a new passing mechanism, pass by reference.
- Under pass by reference, the parameter variables within a function become references, or aliases, for the variables that were passed from the calling function.
- Because the local function parameters just refer to the calling function's variables, any changes made in the called function to pass-by-reference parameters WILL affect the variables in the calling function.
- The parameter in the called function is just another name for the variable in the calling function. There is only one data storage location involved, accessed through either name.
- Pass by reference is indicated by placing an ampersand ( & ) before the variable name in the function prototype and definition. Within the function the variables are treated the same as any other variables.
- Example: In the function below, A is passed by value, and any changes made to it are local to the function. B is passed by reference, and any changes made to it WILL be seen by the function that called this one.
int func1( int A, int & B ) { if( A <= 0 || B <= 0 ) return 0; A += 5; B += 10; return A / B; }
- Functions may only return a single value via the return mechanism, but can have as many pass-by-reference variables as you like, making pass-by-reference an effective method for "returning" multiple results from a single function call. ( For example, it is not uncommon for the actual "return" value to be an error code, ( zero for success or non-zero if problems occur ), and to "return" all the actual results via pass-by-reference variables. )
Passing Arrays and/or Array Elements
- When one element of an array is passed to a function, it is passed in the same manner as the type of data contained in the array. ( I.e. pass-by-value for basic types, unless the function has been written to accept its parameter by reference. )
- However when the entire array is passed, it is effectively passed by reference. ( Actually by pointer/address, not covered in this set of notes. )
- This will be covered further in the section on arrays.
( Pass by Pointer / Address )
- Pass by pointer / address is another type of data passing that you may see in C/C++ textbooks, but which is not covered in these notes. ( It is often mistakenly termed pass-by-reference in older C textbooks, because the actual pass-by-reference passing mechanism was first introduced in C++. )
- Pass by pointer / address requires use of the address operator ( & ) and the pointer dereference operator ( * ), not covered in these notes.
Variable Scope
- Variable scope refers to the range ( the scope ) in which a variable is defined and in which it exists.
- There are four variable scopes: ordinary local variables, function parameters, global variables, and very local variables.
Ordinary Local Variables
- Most of the variables that we have used so far are ordinary local variables.
- Ordinary local variables are declared inside of a function, and outside of any braced blocks such as while or for loops.
- The scope of these variables ( the range in which they exist and are valid ) is from the point of their declaration to the end of the function.
- As a general rule, all ordinary variables are normally declared at the very beginning of a function.
- This was required in C, but is merely a programming style in C++.
- Programmers who work from printouts, and/or who have extensive programming experience in C, tend to define all their variables at the beginning of each function. This has the advantage, especially when working from printouts, of listing all variables in one place, as a sort of comprehensive inventory or checklist.
- Programmers who work mostly or exclusively on the screen, particularly those who learned to program originally in C++ and not C, may prefer to declare their variables as close to where they are first used as possible. This has the advantage of keeping variable declarations and their use on the same screen, or at least within a short distance of each other. There is also some argument for improving compiler optimization performance and for avoiding conflicts with other variables having the same names. ( See "very local variables" and "variable eclipsing" below. )
- For this class you may use either style that you wish, provided you are consistent.
- Ordinary local variables are not initialized automatically. They must be initialized by the programmer, or else they will start out with unknown random values. ( Possibly zeros in some cases, but you can't count on that. )
Function Parameters
- Function parameters have the same scope as ordinary local variables.
- The only difference is that function parameters get initialized with the values passed to them by the calling function.
Global Variables
- Global variables are declared outside of any function, ordinarily at the very beginning of the file.
- The scope of global variables is from the point of declaration down to the end of the file.
- ( Global variables can be made available to functions in other files also, but that is beyond the scope of these notes. )
- Global variables are accessible to all functions within a file ( beyond the point of declaration ), without having to be passed.
- Global variables introduce many opportunities for very hard-to-find bugs, as any function can change them and it can often be very difficult to figure out how a global variable is being changed.
- Some systems may initialize globals to zero ( see static storage below ), but you should not count on that.
- Global variables should be avoided whenever possible. Beginning programmers should not use global variables.
- Globals are most often required when using callback functions, not covered in this course. The introduction of Exceptions in C++ ( also not covered in this course ) has eliminated much of the former need for global variables.
Very Local Variables
- Variables declared within a { braced block }, such as a loop, if, or switch construct are termed very local variables.
- The scope of very local variables is from the point of declaration to the end of the block in which they are declared.
- ( They should normally be declared at the beginning of the block. )
- Programmers sometimes declare very local variables for temporary variables that are only needed within a particular block.
- This is usually done to avoid name conflict problems with other variables having the same name declared in a more general scope. ( See eclipsing below. )
- Very local variables can make code hard to read and understand, and should only be used when there is a very good reason to do so.
- One common use of very local variables is in the code fragment:
for( int i = 0; i < limit; i++ ) {
- In this case the loop counter i exists within the body of the loop, and ceases to exist when the loop exits.
- There will be no conflict between this variable i and any other declared at a more general scope. ( See below. )
- If you choose the variable declaration style of declaring all ordinary local variables at the beginning of the function, then any very local variables you declare should be declared at the beginning of the block in which they are defined.
Variable Eclipsing
- If the same variable name is used in multiple scopes ( e.g. global, local, very local ), and the scopes overlap,then in the regions of overlap the more specific variable will eclipse, or hide the more general variable(s).
- When the more specific variable goes out of scope, then the next more general variable becomes visible again, unchanged by whatever may have occured while it was eclipsed.
- ( The scope resolution operator, ::, may be used to specify a particular scope. For example, ios::fixed refers to the variable "fixed" within the scope of the ios class. )
- Example. In the code below the comments indicate which X will be printed at which locations.
void func( int ); double x( 0.0 ); // Global scope int main( void ) { cout << fixed << setprecision( 1 ) << "First x = " << x << endl; // prints the global, 0.0 int x( 42 ); // Ordinary local cout << "Second x = " << x << endl; // prints the ordinary local, 42 if( x > 40 ) { char x( 'A' ); // Very local, value = 65 cout << "Third x = " << x << endl; // Prints very local, 'A' func( x ); // Passes the very local char, converted to an int. } cout << "Fifth x = " << x << endl; // Ordinary local 42 again return 0; } void func( int x ) { // local parameter cout << "Fourth x = " << x << endl; // Local parameter, 65 return; }
Program Output:
First x = 0.0
Second x = 42
Third x = A
Fourth x = 65
Fifth x = 42
