LAB: INTRODUCTION TO

FUNCTIONS IN C++
MODULE 2

JEFFREY A. STONE and TRICIA K. CLARK

COPYRIGHT 2014
VERSION 4.0

PALMS MODULE 2 LAB: FUNCTIONS IN C++ 2

Introduction
This lab will provide students with an introduction to the fundamentals of user-defined functions
in C++. The focus of this lab is on how to solve simple problems using C++ data types,
variables, and arithmetic operations. At the end of this module, students will

Be able to solve simple problems using C++

Understand the structure of a simple C++ program
Understand the basic C++ data types
Understand and apply the basic concepts behind C++ variables
Understand and be able to apply simple arithmetic expressions using C++ variables
Understand and apply the basic concepts behind C++ arithmetic operators
Understand and be able to apply simple C++ arithmetic expressions

These exercises have two different types of answers. Some questions ask for answers to specific
questions; you should collect these answers in a Microsoft Word document.
Other exercises ask you to write code; for these exercises, structure your storage drive in the
following manner. There should be a palms folder, and within that folder there should be a
LabFunctions folder. All coding exercises (and related folders) for this lesson should be placed
in the LabFunctions folder. Lets begin!

Part 1: Programming With Functions in C++

We've said before that C++ code is broken down into small code segments called functions.
These functions, when combined, form a program. Until now we have only dealt with one
function called main; however, we can define our own functions to make them easier to read and
to maintain. In addition, C++ provides us with a number of useful functions to perform common
tasks, like finding square roots of numbers and converting between different numerical
representations.
In this lab, we will learn how to use some of the built-in C++ functions to simplify our programs,
as well as learn how to create our own. In the future, our programs will grow to include a larger
number of functions.
Functions in C++
Functions are defined as a unit of computational abstraction. In programming, as in life, very
often we want to ignore the small details and concentrate on the big picture. Functions allow us
to do just that, by allowing us to use previously written code to perform a task without worrying
about how the task is performed. For instance, in the following two lines of code:

PALMS for CS1 v4.0

PALMS MODULE 2 LAB: FUNCTIONS IN C++ 3

sum = pow(side1, 2) + pow(side2, 2);
side3 = sqrt(sum);

This code uses two functions that C++ provides in the <cmath> standard library. The first line
uses the pow function to compute the result of raising a number to a power (in this case, the value
of side1 raised to the second power). We don't know how the function works, all we know is
that it will do a certain task and give us a result we desire. Likewise, the second line uses sqrt to
compute the square root of a given number (in this case, the value of sum).
When calling a function in C++, the function name is written first, followed by the inputs in
parentheses. For example, suppose the variable sum contained the value 9. The function call or
invocation sqrt(sum) would return the value 3. Similarly, the call sqrt(25) would return the
value 5, and pow(3, 2) would return the value 32 = 9.
A function call can appear anywhere in a C++ expression. When an expression containing a
function call is evaluated, the return value for that call is substituted into the expression.
For example, in the assignment "value = sqrt(4);", the call on the right-hand side would
evaluate to 2, and so the variable value would be assigned the value 2.
In order to use a function effectively, we need to know the type of data that is returned by the
function. We can only use C++ functions in expressions where data of the same type as the
function's return type is needed. For instance, the following code would not make sense:
char my_char;
my_char = sqrt(30);

Because sqrt returns a real number, it does not make sense to try and place that result into a
variable of type character. Watch and listen to the What is a C++ Function? podcast before
proceeding:

PALMS for CS1 v4.0

PALMS MODULE 2 LAB: FUNCTIONS IN C++ 4

Part 2: User-Defined Functions

Until now we have only used functions that were either (a) required by the language, or (b)
provided by the C++ Standard Library of functions. The standard library functions help to
simplify the programmer's task in two major ways. First, functions help to minimize the amount
of detail of which the programmer must keep track. Since the sqrt function is available, the
programmer does not need to remember the sequence of steps involved in computing the square
root. He or she only needs to remember how to call the sqrt function. Second, functions help to
minimize the size and complexity of code. Once the sqrt function has been defined, a single call
to this function will suffice to compute a square root. Since the number of steps required to
otherwise compute the square root would be considerable, this can represent a significant savings
in the complexity of code.
The C++ Standard Library is designed to provide the programmer with a set of common tools
which can be used without worrying about the nitty-gritty details of how they do their job. These
predefined functions represent a collection of useful, general purpose abstractions. In addition to
these, you are able to define new abstractions by defining your own functions.
Any computation that you find especially useful can be encapsulated as a function. Once defined
and loaded into a C++ file, your function can be called just like any predefined function.
Therefore, your function may be viewed as extending the capabilities of the C++ language itself.
As an example, consider the formula for converting a temperature in degrees Fahrenheit (F) to
degrees Celsius (C):
C = (5.0 / 9.0) * (F - 32)

We can use this formula to create a C++ program. If converting temperatures was a task that you
were to perform relatively often in other programs, you would spend a lot of time remembering
and retyping this formula. Alternatively, you could encapsulate this computation in a function
and save it in a C++ file. Any time you wanted to convert temperatures, you could then add this
C++ file to your project and call the function. You wouldn't need to remember the formula
anymore, just the name of the function and how to call it.
The following is the definition of a C++ function that performs the temperature conversion. A
description of the key parts of this definition is given below:

PALMS for CS1 v4.0

PALMS MODULE 2 LAB: FUNCTIONS IN C++ 5

///////////////////////////////////////////////////////////////////////////
//
//
FUNCTION NAME: fahrToCelsius
//
PARAMETERS: double fahr
-- The degrees in Fahrenheit
//
RETURN TYPE: double
//
PURPOSE: Converts a given degree reading from F to C.
//
///////////////////////////////////////////////////////////////////////////
double fahrToCelsius(double fahr)
{
// variable declarations and initialization
double celsius = 0.0;
// convert the value from F to C...
celsius = (5.0 / 9.0) * (fahr - 32);
// return the converted value...
return celsius;
}

The first eight lines are a function header comment, describing the important aspects of
the function (name, inputs, output, and purpose). You should always have comments in
your functions to improve readability.

The next line is the function header. The header specifies that you are defining a
function named fahrToCelsius with one input. The input value is represented by a
variable inside of the parentheses, also known as a parameter This variable name (fahr)
is preceded by the data type of that variable (in this case, double). When the function is
called, the input specified in the function call is assigned to the parameter for use in the
function's computation. For example, for the call fahrToCelsius(212), the parameter
fahr would be assigned the value 212. Thus, the value 212 would be used in the function
code as the value for fahr, resulting in the function returning the value 100.

The actual code that carries out the computation of the function is enclosed in curlybraces and is called the function body. In this example, there is only three C++ code
statements, but functions can contain any number of statements. A return statement is a
special C++ statement that specifies the value that should be returned by the function. It
consists of the keyword return followed by an expression. When a return statement is
executed, the expression is evaluated and the resulting value is returned as the value of
the function call.

In order to make a user-defined function accessible in a C++ program, it must be included in the
C++ project. This can be accomplished in two ways. When the function is specific to that
program only, its definition can be inserted directly into the .cpp file in the project; for instance,

PALMS for CS1 v4.0

PALMS MODULE 2 LAB: FUNCTIONS IN C++ 6

we could have a single file in our fahrToCelsius project with two functions: main and
fahrToCelsius. Alternatively, general-purpose function definitions can be entered into a
separate library file and loaded into your project. In the future, we will see how to do this.
Exercise #1: Create a new C++ code file called convertTemp.cpp and type the following code
into the file:
///////////////////////////////////////////////////////////////////////////
//
//
Name: convertTemp.cpp
//
Author: Jeffrey A. Stone
//
Purpose: Program which converts a Fahrenheit reading to
//
Celsius.
//
///////////////////////////////////////////////////////////////////////////
#include <iostream>
using namespace std;
///////////////////////////////////////////////////////////////////////////
//
//
FUNCTION NAME: fahrToCelsius
//
PARAMETERS: double fahr
-- The degrees in Fahrenheit
//
RETURN TYPE: double
//
PURPOSE: Converts a given degree reading from F to C.
//
///////////////////////////////////////////////////////////////////////////
double fahrToCelsius(double fahr)
{
// variable declarations and initialization
double celsius = 0.0;
// convert the value from F to C...
celsius = (5.0 / 9.0) * (fahr - 32);
// return the converted value...
return celsius;
}
///////////////////////////////////////////////////////////////////////////
//
//
FUNCTION NAME: main
//
PARAMETERS: None
//
RETURN TYPE: int
//
PURPOSE: Entry point for the application.
//
///////////////////////////////////////////////////////////////////////////

PALMS for CS1 v4.0

PALMS MODULE 2 LAB: FUNCTIONS IN C++ 7

int main()
{
// variable declaration and initialization
double fahr_temp = 0.0;
// variable declaration and initialization
double cel_temp = 0.0;
// prompt the user...
cout << "Enter a reading in fahrenheit degrees : ";
// input the value from the user...
cin >> fahr_temp;
// convert...
cel_temp = fahrToCelsius(fahr_temp);
// output the temperature, in both units...
cout << "You entered " << fahr_temp << " F degrees." << endl
<< "That is " << cel_temp << " C degrees." << endl;
// return success to the Operating System...
return 0;
}

Compile and run the program, and verify that it works as it should.
Next, watch and listen to the Walking Through a Function Call in C++ podcast before
proceeding. This podcast will present a dynamic view of how the above program executes.

PALMS for CS1 v4.0

PALMS MODULE 2 LAB: FUNCTIONS IN C++ 8

Exercise #2: Add a new function to convertTemp.cpp called celsiusToFahr. Modify
the code in main to input two values: the degree reading, along with an F or a C, with the
two values separated by a space.

If the user inputs an F, the degree reading is in Fahrenheit; your program should
convert the degrees to Celsius and output the result to the screen.

If the user inputs a C, the degree reading is in Celsius; your program should
convert the degrees to Fahrenheit and output the result to the screen.

Don't forget to properly comment your code!

Hint: You case use a predefined function called toupper to convert a character from
lowercase to uppercase. This may prove useful for your conditional tests. For example,
simplechar = toupper(simplechar); takes the value of simplechar and (if it is an
alphabetic character) returns the uppercase version of the letter. Simply add #include
<cctype> right below #include <iostream> to gain access to the function.
Local Variables
Notice from Exercise 1 that the function fahrToCelsius contains a single variable declaration,
namely
double celsius = 0.0;

The first line in this function is a variable declaration specifying that the new variable celsius
is to be used in the function. Declaring variables in this way signifies that they are local to the
function, meaning they will only exist inside of the function. In this sense, local variables are
similar to parameters. Declaring a local variable tells the C++ compiler that you are going to use
it as temporary storage while computing the function value, and that the storage should go away
i.e. be returned to the pool of available storage when execution of the function is complete.
In all functions, including main, variables have a defined scope, the area(s) and time for which
they are allowed to be used. In the case of C++ functions, this scope is limited to the code
statements within the beginning and ending brackets ({ }). The lifetime of these variables (i.e.
the time from which memory is allocated by the system to the time in which the memory is given
back) is the time for which the function is executing.
Global variables are variables declared outside of any function. Global variables are thus
accessible by any function within the code file. While the C++ language permits this
functionality, it is generally considered poor programming practice to declare variables with
global scope. Do not declare global variables in any program you create in this course.

PALMS for CS1 v4.0

PALMS MODULE 2 LAB: FUNCTIONS IN C++ 9

Part 3: Function Calling Sequence

Whenever a function is called, a specific sequence of events takes place. If you understand this
sequence, it should be possible to trace the execution of any function and ascertain its behavior.
For example, consider the following program that computes the sum of a range of integers.
///////////////////////////////////////////////////////////////////////////
//
//
Name: sumNumbers.cpp
//
Author: Jeffrey A. Stone
//
Purpose: Sums the numbers in a user-defined sequence.
//
///////////////////////////////////////////////////////////////////////////
#include <iostream>
using namespace std;
///////////////////////////////////////////////////////////////////////////
//
//
FUNCTION NAME: sumNumbers
//
PARAMETERS: long min
-- The lower bound value.
//
long max
-- The upper bound value.
//
RETURN TYPE: long
//
PURPOSE: Sums the numbers from low to high.
//
///////////////////////////////////////////////////////////////////////////
long sumNumbers(long min, long max)
{
long counter = 0;
// keeps a count of the number of loops
long sum = 0;
// keeps a running sum of values
// set the counter to the min value...
counter = min;
while (counter <= max)
{
// Add to our running total...
sum = sum + counter;
// Add to lCounter...
counter = counter + 1;
}
// return the sum of the numbers in the sequence...
return sum;
}

PALMS for CS1 v4.0

PALMS MODULE 2 LAB: FUNCTIONS IN C++ 10

///////////////////////////////////////////////////////////////////////////
//
//
FUNCTION NAME: main
//
PARAMETERS: None
//
RETURN TYPE: int
//
PURPOSE: Entry point for the application.
//
///////////////////////////////////////////////////////////////////////////
int main()
{
long low = 0, high = 0;

// stores the input values

cout << "Enter two integers separated by a space, ";

cout << "smallest integer first : ";
cin >> low >> high;

// prompt
// prompt
// input

cout << "\nThe sum from " << low << " to " << high;
cout << " is " << sumNumbers(low, high) << "\n";

// output
// output

return 0;

// return "success" to the operating system

When the sumNumbers function is called in the main function, the following events occur:
1. Execution shifts to the sumNumbers function.
2. The inputs to the function are evaluated first, with the parameters min and max assuming
the values contained within low and high, respectively.
3. Within the function, new memory cells are allocated for the parameters min and max.
These memory cells are assigned the values of the corresponding arguments from the
call: the values contained within the variables low and high, respectively. Throughout the
function, any references to these parameters will be associated with these memory cells.
4. Memory cells are next allocated (created) for each local variable: counter and sum.
Similarly, any references within the function to these local variable names will be
associated with these memory cells. They are initialized with a zero value.
5. The statements in the function are executed in order, assigning sum the value of the sum
of the integers from min to max.
6. When the return statement is reached, the expression in the statement is evaluated,
yielding the value contained within sum.
7. After computing the return value, the execution of the function is over. Since the local
variables exist only inside the function itself, the memory cells associated with the
variables are de-allocated, i.e., made available for other uses.
8. Similarly, the memory cells associated with parameters are de-allocated.

PALMS for CS1 v4.0

PALMS MODULE 2 LAB: FUNCTIONS IN C++ 11

9. Once the memory cells have been freed, the value in sum can be returned as the value of
the function call. In this case, the value returned by the function replaces the function call
in the assignment, and so that value is output to the screen.
In general, the calling sequence for functions is as follows:
1. The arguments in the function call are evaluated.
2. Execution shifts to the function being called.
3. Memory cells are allocated (created) for each parameter in the function, and the values of
the corresponding arguments are assigned to these memory cells.
4. Memory cells are allocated (created) for each local variable.
5. The statements in the body of the function are executed in order.
6. When a return statement is encountered, the expression is evaluated.
7. Memory cells associated with the local variables are de-allocated (destroyed).
8. Memory cells associated with the parameters are de-allocated (destroyed).
9. Upon return, the value of the expression in the return statement replaces the function call
in whatever expression it appears in.
Watch and listen to the Function Calling Sequence podcast before proceeding:

Exercise #3: Create a new C++ workspace called incomeTax. Your main function should
prompt the user for his/her gross income and itemized deduction (both double values). Construct
a function called incomeTax which computes the tax due using the input values (gross income
and itemized deduction) as follows:

PALMS for CS1 v4.0

PALMS MODULE 2 LAB: FUNCTIONS IN C++ 12

The taxpayer's taxable income is determined by subtracting the taxpayers

deduction from the taxpayer's gross income.

Total tax is determined by multiplying the taxable income by the tax rate (0.17).

Your main function should call your incomeTax function to compute the total tax due, giving it
appropriate arguments. Your incomeTax function should return the total tax due back to your
main function. Finally, your main function should output the tax due to the screen with a
descriptive message.
Please watch and listen to the Techniques for User-Defined Functions in C++ podcast before
proceeding. This podcast will present a description of how to create input,
processing/computation, and output functions. These tips will be used heavily in this course.

Part 4: Calculating the Energy Produced by a Wind Generator

Suppose you wanted to harness to power of wind to generate electricity. One question you might
want to ask is: what is the amount of power my wind generator can produce? To answer this
question, you will need at least the following information:

The average wind speed in your backyard (in m/s)

The operating efficiency of your wind generator (in %)
The radius of the blades on your wind generator (in meters)

PALMS for CS1 v4.0

PALMS MODULE 2 LAB: FUNCTIONS IN C++ 13

To compute the maximum power output for your wind generator, you will need the following
math formulas:

= 2 , which represents the cross-sectional area of a circle ( = 3.14159265).

1
= 2 3 , which calculates the maximum available power given the wind speed
(), cross-sectional area of the blades (A), and the density of the air (= 1.2 kg/3 ).

Once you have the maximum available power, computing the actual amount of power (not the
maximum) produced by the wind generator is a matter of determining the amount of power
based on the operating efficiency.
Exercise #4: Create a program to compute the amount of power produced by a wind generator.
Your program should take three double precision inputs (see the discussion above) before
performing its calculations. Create two functions other than main in your program. Both of these
functions will return a double value. One function should be called computeArea and should
take one double parameter named radius. The other function should be called
computeMaximumPower and should take two double parameters (named area and wind_speed).
You will need to call these functions from main function.
Your output should include two calculated results the maximum power output and the actual
power output. All numeric amounts should be precise to two decimal places. Remember: a
percentage is really a number between 0 and 1, inclusive. Here are few sample tests you can run
to check if your program is working correctly:
Test Case #1:
Enter the Average Wind Speed (in m/s): 5.0
Enter the Operating Efficiency [0...1]: 0.98
Enter the Blade Radius (in meters): 2.0
Maximum Power = 942.48, Actual Power = 923.63.

Test Case #2:

Enter the Average Wind Speed (in m/s): 12.29
Enter the Operating Efficiency [0...1]: 0.10
Enter the Blade Radius (in meters): 3.0
Maximum Power = 31491.93, Actual Power = 3149.19.

PALMS for CS1 v4.0

PALMS MODULE 2 LAB: FUNCTIONS IN C++ 14

Part 5: Vocabulary Words

You will be assessed on your knowledge of the following terms and concepts as well as the
function concepts discussed in this document. As a result, you are encouraged to review these
terms in the preceding document.
Argument a value that is provided in a function call to fill in a parameter. Arguments
provide functions with the data necessary to complete its task.
Comment a statement, sentence, or phrase which describes a piece of code. Comments are
ignored by the compiler and exist only to document the C++ code with a more natural
language (e.g. English). In C++, single-line comments begin with //. Multi-line comments
are bounded with /* and */.
C++ Standard Library a set of common tools which can be used in any program. These
predefined functions and classes represent a collection of useful, general purpose
abstractions.
Function a specific unit of code in C++ containing a header and a body. Functions can be
called by other functions to perform tasks, and can return a value back to the
caller.
Function Body The actual code that carries out the computation of the function; that part of
the function which is enclosed in curly-braces.
Function Call the act of invoking a function. A function call is made by using the function
name and providing the function with any necessary arguments.
Function Header the first line of a function, containing the function name, the parameter list,
and the type of data returned by the function.
Local Variable a variable declared within a set of { }, such as a function body. Local variables
can only be used within that set of { }. Declaring a local variable tells the C++ compiler
that you are going to use it as temporary storage while computing the function value, and
that the storage should go away i.e. be returned to the pool of available storage when
execution of the function is complete.
Parameter a value that a function expects to be given when the function is called. A
function can have 0 or more parameters. These are placeholders that must be filled in
by arguments when the function is called. As a result, parameters can take on different

PALMS for CS1 v4.0

PALMS MODULE 2 LAB: FUNCTIONS IN C++ 15

values each time the function is called. Parameters act as local variables within the
function body.
Parameter List a set of parameters, enclosed in parentheses within the function header.
Parameter lists follow the function name in a function header. Each parameter is declared
using a data type and a name, much like a variable declaration. The parameter
declarations in the list are separated by commas.
Return Statement a special C++ statement that specifies the value that should be returned by
the function; begins with the keyword return.
Scope the visibility or lifetime of a variable. All variables have a defined area and time for
which they are allowed to be used. In the case of C++ functions, this scope is limited to
the code statements within the beginning and ending brackets ({ }). The lifetime of these
variables (i.e. the time from which memory is allocated by the system to the time in
which the memory is given back) is the time for which the function is executing.

PALMS for CS1 v4.0