a function (procedure)

code to performa task (carryout an algorithm)

Return_type Func(parameters)

---- Func (arguments)---

Returnvalue

Parameters• Java parameters are either

– primitive types - parameter is a copy of the argument (argument cannot be changed)

– objects - parameter is an alias for the argument (argument can be changed)

• C++ parameters are either– value parameters– reference parameters– constant reference parameters– array parameters

Java parameter passing

public void myMethod (int number, SomeClass myObj) { --- ---}

number

myObj

36activation record (memory space) created when myMethod is called

obj.myMethod (intArg, objArg);

36intArg

objArg

C++ Parameters

• C++ parameters are either– value - (type param_name)

• parameter is a copy of the argument, thus argument cannot be modified

– reference - (type & param_name)• parameter is an alias for the argument, thus argument is modified

if parameter is modified

– constant reference - (const type & param_name)• parameter is an alias for the argument, but compiler

disallows assignment to parameter

C++ parameter passing

void myFunction (int val, int & ref, const int & constref) { --- ---}

v

36

myFunction (v, r, cr);

r

25

cr

6

36val

ref

activation record (memory space) created when myFunction is called constref

Decomposition Example

main

InstructGetEmployee

InfoGrossWages

ComputeNetPay

PrintEmpInfo

from Figure C.6 Using Functions on p.781

/* Program to compute wages for several employees. Written at ___________ by _________________- Input: Id-number, number of dependents, hours worked, and hourly rate for each of several employees Output: Id-number, hours worked, gross pay, taxes withheld and net pay____________________________________________________*/#include <iostream>#include <iomanip>using namespace std;

void Instruct ( );void GetEmployeeInfo (int & empNumber, int & dependents, double & hours, double & rate, bool & done);double GrossWages (int dependents, double hours, double rate);void ComputeNetPay (double grossPay, int dependents, double & tax, double & netPay);void PrintEmpInfo (int idNumber, double hours, double grossPay, double taxes, double netPay);

int main ( ){ -----}

int main ( ){ int idNumber, // employee's id-number numDependents; // number of dependents double hoursWorked, // hours worked this pay period hourlyRate, // dollars per hour grossPay, // pay before taxes taxWithheld, // amount of tax withheld netPay; // grossPay - tasWithheld bool endOfData; // signals end of data Instruct ( ); for ( ; ; ) { GetEmployeeInfo (idNumber, numDependents, hoursWorked, hourlyRate, endOfData); if (endOfData) break; // MUST BE CHANGED!! grossPay = GrossWages (numDependents, hoursWorked, hourlyRate); ComputeNetPay (grossPay, numDependents, taxWithheld, netPay); PrintEmpInfo (idNumber, hoursWorked, grossPay, taxWithheld, netPay); } return 0;}

int main ( ){ int idNumber, // employee's id-number numDependents; // number of dependents double hoursWorked, // hours worked this pay period hourlyRate, // dollars per hour grossPay, // pay before taxes taxWithheld, // amount of tax withheld netPay; // grossPay - tasWithheld // bool endOfData; // signals end of data

Instruct ( ); while (GetEmployeeInfo (idNumber, numDependents, hoursWorked, hourlyRate)) { // if (endOfData) break; // TO BE CHANGED!! grossPay = GrossWages (numDependents, hoursWorked, hourlyRate); ComputeNetPay (grossPay, numDependents, taxWithheld, netPay); PrintEmpInfo (idNumber, hoursWorked, grossPay, taxWithheld, netPay) } return 0;}

Change Needed?

void GetEmployeeInfo (int & empNumber, int & dependents, double & hours, double & rate, bool & done);

bool GetEmployeeInfo (int & empNumber, int & dependents, double & hours, double & rate);

/* bool GetEmployeeInfo (int & empNumber, int & dependents, double & hours, double & rate) Purpose: read information for one employee Precondition(s): none Postcondition(s): The four parameters have been assigned values Returns: false if end of data reached; true otherwise--------------------------------------------------------------------------------------------*/

bool GetEmployeeInfo (int & empNumber, int & dependents, double & hours, double & rate){ cout << "\nEnter employee number (0 to stop): "; cin >> empNumber; if (empNumber == 0) return false; cout << "Enter # of dependents, hours worked, and hourly rate for " << empNumber << ": "; cin >> dependents >> hours >> rate; return true;}

/* double GrossWages (int dependents, double hours, double rate) Purpose: compute gross wages as determined by number of hours employee worked plus a dependency allowance for each dependent. Precondition(s): dependents, hours and rate >= 0 Postcondition(s): none Returns: Gross wages--------------------------------------------------------------------------------------------*/

double GrossWages (int dependents, double hours, double rate){ const double DEP_ALLOWANCE = 100; // bonus per dependent double wages; // wages earned if (hours <= 40) // no overtime wages = hours * rate; else // overtime wages = 40 * rate + 1.5 * rate * (hours - 40); return wages + DEP_ALLOWANCE * dependents;}

/* void Instruct ( ) Purpose: Display instructions to the user Precondition(s): none Postcondition(s): instructions have been displayed on the screen Returns: nothing**********************************************************************************/

/* void ComputeNetPay(double grossPay, int dependents, double & tax, double & netPay) Purpose: compute taxes withheld and net pay Precondition(s): grossPay and dependents are valid Postcondition(s): tax and netPay have been assigned computed values Returns: nothing************************************************************************************/

/* void PrintEmpInfo( int idNumber, double hours, double grossPay double taxes, double netPay) Purpose: display payroll information regarding one employee Precondition(s): idNumber, hours, grossPay, taxes and netPay are valid Postcondition(s): payroll information has been displayed on the screen Returns: nothing*************************************************************************************/

Programming & Problem Solving

Representationof real worldproblem

Processing algorithms Representationof results

Real worldproblem

Real worldresults

PROBLEM DOMAIN

PROGRAM DOMAIN

Variables (data objects)

• Components of a data object– name (programmer defined)– address (memory location)– type – value (determined by interpretation of the

sequence of bits stored in memory)

• type name [= value];

10011100

Types

• predefined (built-in) vs programmer defined• simple (fundamental) vs structured• type of a data object determines

– number of bytes used to store the value

– interpretation of the bit pattern stored in those bytes

– possible operations

• data abstraction refers to the separation of the use of a data type from the implementation details

C++ Types

Characters

Integral Floating point (reals)

charshort int

int

unsigned short unsigned

floatdouble

long double

IntegersEnumerations

Arithmetic void pointers structunion

priority_queuelong int

unsigned long

unsigned char signed char

array

bool complex

Fundamental Types Structured Types

valarray

vectordequelist

set

map

multiset

multimap

stackqueue

string

bitset

istreamostream

iostreamifstreamofstreamfstream

C++ StandardLibrary classes

C++ arrays

• groups data items of same type under one name– double Numbers[4];– int List = {45, 63, 22};

• individual items accessed by indexing– Numbers[2] = 85.3;– first array element is at index position 0

• C++ arrays are not objects– no length data member

• number of elements is determined either– at compile-time (both examples above)– at run-time (coming later)

C++ array implementation

• array name is a variable whose value is the base address of the array, i.e. a pointer variable

• accessing an individual element involves calculating its address– base_address + index * element_size

List

45 63 22

b b+1 b+2 b+3 b+4 - - - - - - - - - - b+8 - - - - - - - - - - b+12

List[0] List[1] List[2]

Alternative Syntax• Given: int List = {45, 63, 22};

• first element can be accessed by– List[0];– *List; // * is the dereferencing operator

• second element can be accessed by– List[1];– *(List + 1);

• what is the value of List?

• always use the indexing notation

C++ array parameters

void func (double A[ ], int N) { --- ---} arguments provided when

func is called

Numbers

N

4

activation record (memory space) created when func is called

A

N

4

3.2 2.1 5.9 7.0

const

C++ structs

• struct - group of data items of different types– struct person {

string Name; int Age;};

– person is a type grouping together 2 data members– person OneStudent; //represents 1 person– person Class[25]; //represents 25 persons

• dot operator (.) used to access members– Class[i].Age

• struct to struct assignments are legal– Class[i] = Class[i+1];

Creating New C++ Types

• enumeration– allows defining your own set of values for a scalar type

• typedef – allows for defining a synonym or alias for an existing type

• struct– allows a variable to have multiple values of different types

• class– allows encapsulating data members and operations

Enumeration

• used to make a program more readable• associates a set of programmer defined values with the

integer values 0, 1, 2, - -• Example

– enum Suit {CLUBS, SPADES, HEARTS, DIAMONDS};

– Suit mySuit = HEARTS;– if (mySuit == SPADES) ---– switch (mySuit) {

case CLUBS: ---- case SPADES: ---

typedef statement

• used to declare a new name (synonym) for an already existing type– const int SIZE = 100;– typedef int intArrayType[SIZE];– intArrayType numberList;

• usually given global (file) scope• used to make a program easier to modify

C++ strings

• early versions of C++ used “C-style strings”– array of char with a special character (null character)

marking the end

– <string.h> or <cstring> have functions to manipulate C-style strings

• C++ standard library provides the class string– #include <string>

– use C++ string class, not C-style strings

– see Ch.3 sec.4 for information and examples; also TableD.4