intro to functions.pdf

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

PALMS for CS1 v4.0

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. Let’s 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

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:

http://www.personal.psu.edu/jas86/PALMS/mod2/functions1/



PALMS for CS1 v4.0

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

///////////////////////////////////////////////////////////////////////////

//

// 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 curly-

braces 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

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


// 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

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.

http://youtu.be/RK_E_MX1edg

http://youtu.be/RK_E_MX1edg


PALMS for CS1 v4.0

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


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

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

///////////////////////////////////////////////////////////////////////////

//

// 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, "; // prompt

cout << "smallest integer first : "; // prompt

cin >> low >> high; // input

cout << "\nThe sum from " << low << " to " << high; // output

cout << " is " << sumNumbers(low, high) << "\n"; // 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

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

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

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

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

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

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.

intro to functions.pdf

Documents

Transcript of intro to functions.pdf