1. a function (procedure) code to perform a task (carry out an algorithm) Return_type Func(parameters) ---- Func (arguments) --- Return value

2. 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

3. Java parameter passing public void myMethod (int number, SomeClass myObj) { --- } number myObj 36 activation record (memory space) created when myMethod is called obj.myMethod (intArg, objArg); 36 intArg objArg

4. 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

5. C++ parameter passing void myFunction (int val, int & ref, const int & constref) { --- } v 36 myFunction (v, r, cr); r 25 cr 6 36 val ref activation record (memory space) created when myFunction is called constref

6. Decomposition Example main Instruct GetEmployee Info GrossWages Compute NetPay Print EmpInfo from Figure C.6 Using Functions on p.781

7. /* 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 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 ( ) { ----- }

8. 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; }

9. 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; }

10. Change Needed? void GetEmployeeInfo (int & empNumber, int & dependents, double & hours, double & rate, bool & done); bool GetEmployeeInfo (int & empNumber, int & dependents, double & hours, double & rate);

11. /* 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; }

12. /* 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; }

13. /* 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 *************************************************************************************/

14. Programming & Problem Solving Representation of real world problem Processing algorithms Representation of results Real world problem Real world results PROBLEM DOMAIN PROGRAM DOMAIN

15. 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

16. 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

17. C++ Types Characters IntegralFloating point (reals) char short int int unsigned short unsigned float double long double IntegersEnumerations Arithmetic void pointers struct union priority_queue long int unsigned long unsigned char signed char array boolcomplex Fundamental Types Structured Types valarray vector deque list set map multiset multimap stack queue string bitset istream ostream iostream ifstream ofstream fstream C++ Standard Library classes

18. 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)

19. 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 456322 b b+1 b+2 b+3 b+4 - - - - - - - - - - b+8 - - - - - - - - - - b+12 List[0] List[1] List[2]

20. 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

21. 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 ANAN 4 3.2 2.1 5.9 7.0 const

22. 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];

23. 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

24. 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: ---

25. 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

26. C++ strings early versions of C++ used “C-style strings” –array of char with a special character (null character) marking the end – or have functions to manipulate C-style strings C++ standard library provides the class string –#include –use C++ string class, not C-style strings –see Ch.3 sec.4 for information and examples; also TableD.4