Functions 2: Void (NonValue-Returning) Functions

Void (NonValue-Returning) functions:

Void functions are created and used just like value-returning functions except they do not return a value after the function executes. In lieu of a data type, void functions use the keyword "void." A void function performs a task, and then control returns back to the caller--but, it does not return a value. You may or may not use the return statement, as there is no return value. Even without the return statement, control will return to the caller automatically at the end of the function. A good utilization of a void function would be to print a header/footer to a screen or file.

Remember: there are two kinds of subprograms that the C++ language utilizes: value-returning functions and void functions. Both value-returning functions and void functions receive values through their parameter lists. A value-returning function can only return one value to the calling environment. The caller invokes (calls) a value-returning function by using its name and argument list in an expression (i.e., 1. assignment, 2. output, or as an 3. argument in another function call):

//value-returning function call (assignment):
y = 2.0 * sqrt(x);

In contrast, a void function (method or procedure, in other languages) does not return a function value. Nor is it called from within an expression. Instead, the function call appears as a complete, stand-alone statement. One example is the get function associated with the istream and ifstream classes:

//void function call:
cin.get();

Another example:

//void function call:
printName(name);

Bjarne Stroustrup's C++ Glossary

• Both: require function definitions (i.e., headers and bodies)
• Both: definitions can be placed before or after function main()...
  though, if placed after main() function, prototypes must be placed before main()
• Both: formal parameter list can be empty--though, parentheses still required
• Both: actual parameter list can use expression or variable, but must match in "TON": type, order, number

• Void function: does not have return type
• Uses keyword void in function header
• Call to void function is stand-alone statement

//Void (NonValue-returning) function definition syntax: including header and body
void functionName(formal parameter list) //function header
{
   //function body
   statements...

   //void (nonvalue-returning) function can still use return statement
   //but, does not return any values...
   return;
}

//function call syntax:
functionName(actual parameter list); //stand-alone statement only

• Call to void function with empty formal parameter list:

functionName(); //stand-alone statement only

Function Parameters

Function Parameter Types:
Two Types of Function Parameters:

1. Value Parameter: formal parameter receives copy of content of corresponding actual parameter
2. Reference Parameter: formal parameter receives location (memory address) of corresponding actual parameter

• Value of corresponding actual parameter copied into formal parameter
• Value parameter has own copy of data
• During program execution, value parameter manipulates data stored in own memory space
• Value parameters will accept expressions, constants, or variables from actual parameters (i.e., in function call)

//Void (NonValue-returning) function definition syntax: including header and body
void functionName(dataType variable, dataType variable) //function header
{
   //function body
   statements...

   //void (nonvalue-returning) function can still use return statement
   //but, does not return any values...
   return;
}

• Formal parameter receives and stores address of corresponding actual parameter
• During program execution, address stored in reference parameter can modify data of corresponding actual parameter, by sharing same memory space
• Reference parameters can: pass one or more values from function, and can change value of actual parameter
• Reference parameters useful in three situations:
1. Returning more than one value
2. Changing value of actual parameter
3. When passing address would save memory space and time
• ***Reference parameter limitations: reference parameters will not accept expressions or constants from actual parameters (i.e., in function call), ONLY variables

//Void (NonValue-returning) function definition syntax: including header and body
void functionName(dataType& variable, dataType& variable) //function header
{
   //function body
   statements...

   //void (nonvalue-returning) function can still use return statement
   //but, does not return any values...
   return;
}

//Void (NonValue-returning) function call with arguments 
functionName(expression or constant or variable, expression or constant or variable); //stand-alone statement only

//Void (NonValue-returning) function call with arguments 
functionName(variable, variable); //stand-alone statement only

Function Parameters And Memory Allocation

When a function is called:

• Memory for formal parameters (in header) and (local) variables declared in body of function allocated in function data area
• Value parameter: value of actual parameter copied into memory cell of its corresponding formal parameter
• Reference parameter: address of actual parameter passed to formal parameter (content of formal parameter is an address)
• During execution, changes made by formal parameter permanently change value of actual parameter
• Stream variables (e.g., ifstream and ofstream) should be passed by reference to function

1. Makes copy of actual parameter
2. Passes copy of contents
3. Original variable's contents DO NOT change
4. How? Do nothing. Default.
5. Safer

1. Passes address of actual parameter
2. Accesses original variable's contents (via address)
3. Original variable's contents DO change
4. How? Add ampersand (&) before parameter name in header and prototype
5. More efficient

Note: Although the C++ language allows value-returning functions to have both value parameters and reference parameters, it is not recommended. By definition, a value-returning function returns a single value; this value is returned via the return statement. Use void functions with reference parameters to return (modify) more than one value.

/*
This program demos void functions using
  value parameters vs. reference parameters

Reference Parameter:
If a formal parameter is a reference parameter, it
receives the address of the corresponding actual
parameter

A reference parameter stores the address of the
corresponding actual parameter

During program execution to manipulate the data,
the address stored in the reference parameter directs
it to the memory space of the corresponding actual
parameter
*/

//header files
#include<iostream>
using std::cout;
using std::cin;
using std::endl;

//prototype functions
void readDate(int& month, int& day, int& year); //reference parameters
void printDate(int month, int day, int year); //value parameters

//initialize constants

//initialize global variables

int main()
{
  //initialize automatic variables
  int mm, dd, yy;
  readDate(mm, dd, yy);
  printDate(mm, dd, yy);

  cout << "Press Enter key to exit...";
  cin.get(); cin.get(); // make DOS window stay open

  return 0;
}

//function definitions
void readDate(int& month, int& day, int& year)
{
  char ch; //local variable
  cout << "Enter a date (mm/dd/year): ";
  cin >> month >> ch >> day >> ch >> year;
}
 
void printDate(int month, int day, int year)
{
  cout << "The date is " << month << '-' << day;
  cout << '-' << year << endl;
}

Void or Value-Returning Functions?

When to use Void or Value-Returning Functions:

• Void Function: when must return more than one value or modify any of the caller's arguments
• Void Function: when must perform I/O
• Void Function: when in doubt, can recode any value-returning function as void function by adding additional outgoing parameter
• Value-returning Function: when only one value returned

Scope

What is scope?

• Scope of an identifier refers to where in program an identifier is accessible
• Local identifier: declared within a function (or block)
• Global identifier: declared outside of every function definition
• C++ does not allow nested functions (i.e., definition of one function cannot be included in body of another function)
• However, can call another function from within a function

• Global identifier's (e.g., variables) accessibility within function (or block):
• Identifier must be declared before function definition (block)
• Scope of identifier declared outside of all namespaces, functions, and classes extends from point of declaration to end of file containing program code
• Names of function(s), parameter(s), and local identifier(s) must be different than global identifier (see exceptions below)
• Exception: global variable declared before definition of function (block) can be accessed by function (or block),
  even if function (or block) has an identifier with same name--by using scope resolution operator (::)
• Exception: C++ provides a way to access a global variable declared after definition of function--external variable. As a rule, functions should not contain any identifier with same name as global variable. Syntax for declaring external variable: extern int var;

A global variable, that is a variable declared outside of all functions in a file, is accessible by any code in that file. By declaring extern variables, for programs that require multiple files, variables declared in one file can be accessible in other files. Variables that are declared as extern are often placed in an include file that is used by any file requiring access to the external variable. If there are multiple variables with the same name whose scopes overlap at one point in a program, the variable with the innermost scope will be used.

• Another Exception: C++ allows function overloading, that is various functions with same name perform different operations (though, must have different parameters)
• Function names have global scope
• Local identifier's accessibility within function or nested block:
• Accessible from point of declaration to end of block, and...
• By blocks nested within same function or block--provided that
  names of additional identifier(s) are different than identifier outside of nested block(s)
• C++ allows the declaration of variables anywhere within a program, subject to the declare before use rule.
  C requires variable declarations at the beginning of a block. Here is code illustrating scope of three variables:

                                //   scopes:
                                //  x  i  j  k
float x;                        //  |
int main()                      //  |
{                               //  |
  int i;                        //  |  |
  for (int j = 0; j < 100; ++j) //  |  |  |
  {                             //  |  |  |
    std::cin >> i;              //  |  |  |
    int k = i;                  //  |  |  |  |
    // more code                //  |  |  |  |
  }                             //  |  |
  return 0;                     //  |  |
}                               //  |


Note that x is global, i and j are local. The following code is more subtle.

#include <iostream>
int main()
{
  std::cout << "\nStarting Program\n";
  {
    int x = 5;// declare new variable
    std::cout << "x = " << x << '\n';
    {
      int x = 8;
      std::cout << "x = " << x << '\n';
    }
    std::cout << "x = " << x << '\n';
    {
      x = 3;
    }
    std::cout << "x = " << x << '\n';
  }
}

You can run the program to be sure you understand how scope rules affect the
values of the variables. 

• Scope of identifier declared in namespace definition extends from point of declaration to end of namespace body
• Identifier's scope includes scope of using directive specifying that namespace
• 3 Ways to Implement Namespace Identifiers:
1. Qualified name: namespace, scope resolution operator (::) and identifier

  std::cout << "Namespace test";

2. Using declaration:

  using std::cout;
  cout << "Namespace test";

3. Using directive (local or global):

  using namespace std;
  cout << "Namespace test";

• Because of global variable's accessibility:
• Can cause "dependency" issues in other parts of program (e.g., identifier names)
• Difficult to debug problems
• Make unit testing difficult (isolated units of code)
• Make it difficult to "decentralize" software into modules or components

1. Since global variables are shared by different modules, they make each of these modules more difficult to understand separately, diminishing readability and hence hampering maintenance.
2. As global variables constitute a form of undercover dependency between modules, they are a major obstacle to software evolution, since they make it harder to modify a module without impacting others.
3. They are a major source of nasty errors. Through a global variable, an error in a module may propagate to many others. As a result, the manifestation of the error may be quite remote from its cause in the software architecture, making it very hard to trace down errors and correct them. This problem is particularly serious in environments where incorrect array references may pollute other data.
4. There is also another problem, less fundamental but still annoying: since a global variable does not belong to any one module in particular, it is not clear where it should be initialized.

Global Variables

1. Function names have global scope
2. Function parameter's scope is identical to scope of local variable declared in outermost block of function body
3. Global variable's (or constant's) scope extends from its declaration to end of program file, except as noted in rule 5
4. Local variable's (or constant's) scope extends from its declaration to end of block where declared, including any nested blocks, except as noted in rule 5
5. Identifier's scope does not include any nested block that contains a locally declared identifier with same name (local identifiers have name precedence)

Lifetime

What is lifetime?

• Identifier lifetime: time during program execution in which identifier stored in memory
• Automatic variable:
• Keyword auto
• Memory allocated at block entry and deallocated at block exit
• Local variables are automatic storage class by default so auto seldom used
• Variables declared within a block are automatic variables
• Static variable:
• Memory remains allocated as long as program executes
• Variables declared outside any block are static (and global) variables
• Static variables declared within block are local to block
• Scope of static variable same as other local identifiers of that block
• Can also declare static variable within block by using reserved word static
• Syntax for declaring static variable:

  static dataType identifier;

  static int x; //static variable of type int

Stub Functions

Using Stub Functions:

Stub functions may be used when testing programs. A stub function is a stripped-down, skeletal structure of the actual function. It does not implement the full details of the algorithm or function requirements. It does contain the parameter lists. Essentially, a stub is a dummy function with a limited body, usually just output statements that acknowledge the function was reached, and a return value (if any) of the correct type. Usually, the stub function's name and parameter list is the same as the function that will actually be called by the program being tested.

Function Overloading

What is Function Overloading:

Several functions with the same name is called function overloading. Generally, function overloading is used when different data types will be used with the same function. As an illustration, one function may accept integer values, while another can receive char or float data. Of course, you could implement the same functionality using a different function name whose parameters would receive the various data types--or, you can employ function overloading.

When overloading a function, dissimilar signatures (i.e., different "TON": type, order, or number) must be used for each overloaded version. A function signature consists of a list of data types of its parameters, as well as their order, and number (i.e., the number of parameters).

Lastly, a function differing only by return type, OR different parameter names is illegal (though, it is legal to use a different return type with a different parameter list--that is, different "TON." See below):

//valid overloaded function prototypes (applicable to definitions as well)...
void myFunc();
void myFunc(int i);
void myFunc(char c);
void myFunc(char c, int i);
void myFunc(int i, char c);
void myFunc(string & s);

//Error: differs from void myFunc(); only by return type
int myFunc();

//OK: Different "TON" (i.e., unique signature)
int myFunc(float f);

/*
The functions myFunc, using the same number of parameters (two, with
just different names), and the same data
types (int and char), in the same order, have the same formal
parameter list, and, is therefore illegal...
*/
void myFunc(int myInt, char myChar); //illegal--same "TON"

• Function overloading: create several functions with same name
• Function signature: function name and its formal parameter list
• Two functions using different signatures: different names or different formal parameter lists (i.e., different "TON")
• Note: different function signatures do not include different return types, or different parameter names

Functions with Default Parameters

Using Functions with Default Parameters:

When a function is called, the number of actual and formal parameters must be the same except in the case of default parameters. The value of a default parameter is specified when the function name appears for the first time (as in the prototype).

The following rules apply to default parameters:

• Specify default parameter values when function name appears for first time (as in the prototype)
• If no default parameter value is specified, the default value is used
• All default parameters must be the rightmost parameters of function
• In function call where function has more than one default parameter, and a value to a default parameter is not specified, must omit all of arguments to its right
• Default values can be constants, global variables, or function calls
• Caller has option of specifying a value other than the default for any default parameter
• Cannot assign constant value as default value to reference parameter

//function prototype...applies to definitions as well...
void myFunc(int x, int y, double t, char z = 'A', int u = 50, 
char v='B', double w = 18.56);

//local variables
int a, b;
char ch;
double d;

//legal function calls
myFunc(a, b, d);
myFunc(a, 15, 36.1, 'C', 92, ch);
myFunc(b, a, 13.21, 'D');

//illegal function calls
myFunc(a, 15, 33.1, 62.3);
myFunc(b, 25, 32.9, 'E', 1234, 92.7);

Recursion

A Recursive Function:

• Calls itself
• Knows how to solve the simplest case(s), or base case(s)
• If the function is called with a base case it simply returns the result without recursion
• To terminate, the sequence of recursive calls must converge on the base case.

• Both: are based on a control statment
• Both: involve repetition
• Both: involve a termination test
• Both: gradually approach termination
• Both: can result in an infinite loop

• Repeatedly overhead of function calls
• Can be expensive in both processor time and memory space
• Each call creates another set of the functions variables